<?xml version="1.0"?>
<doc>
    <assembly>
        <name>NLog</name>
    </assembly>
    <members>
        <member name="T:JetBrains.Annotations.CanBeNullAttribute">
             <summary>
             Indicates that the value of the marked element could be <c>null</c> sometimes,
             so checking for <c>null</c> is required before its usage.
             </summary>
             <example><code>
             [CanBeNull] object Test() => null;
            
             void UseTest() {
               var p = Test();
               var s = p.ToString(); // Warning: Possible 'System.NullReferenceException'
             }
             </code></example>
        </member>
        <member name="T:JetBrains.Annotations.NotNullAttribute">
            <summary>
            Indicates that the value of the marked element can never be <c>null</c>.
            </summary>
            <example><code>
            [NotNull] object Foo() {
              return null; // Warning: Possible 'null' assignment
            }
            </code></example>
        </member>
        <member name="T:JetBrains.Annotations.ItemNotNullAttribute">
            <summary>
            Can be applied to symbols of types derived from IEnumerable as well as to symbols of Task
            and Lazy classes to indicate that the value of a collection item, of the Task.Result property
            or of the Lazy.Value property can never be null.
            </summary>
            <example><code>
            public void Foo([ItemNotNull]List&lt;string&gt; books)
            {
              foreach (var book in books) {
                if (book != null) // Warning: Expression is always true
                 Console.WriteLine(book.ToUpper());
              }
            }
            </code></example>
        </member>
        <member name="T:JetBrains.Annotations.ItemCanBeNullAttribute">
            <summary>
            Can be applied to symbols of types derived from IEnumerable as well as to symbols of Task
            and Lazy classes to indicate that the value of a collection item, of the Task.Result property
            or of the Lazy.Value property can be null.
            </summary>
            <example><code>
            public void Foo([ItemCanBeNull]List&lt;string&gt; books)
            {
              foreach (var book in books)
              {
                // Warning: Possible 'System.NullReferenceException'
                Console.WriteLine(book.ToUpper());
              }
            }
            </code></example>
        </member>
        <member name="T:JetBrains.Annotations.StringFormatMethodAttribute">
             <summary>
             Indicates that the marked method builds string by the format pattern and (optional) arguments.
             The parameter, which contains the format string, should be given in the constructor. The format string
             should be in <see cref="M:System.String.Format(System.IFormatProvider,System.String,System.Object[])"/>-like form.
             </summary>
             <example><code>
             [StringFormatMethod("message")]
             void ShowError(string message, params object[] args) { /* do something */ }
            
             void Foo() {
               ShowError("Failed: {0}"); // Warning: Non-existing argument in format string
             }
             </code></example>
        </member>
        <member name="M:JetBrains.Annotations.StringFormatMethodAttribute.#ctor(System.String)">
            <param name="formatParameterName">
            Specifies which parameter of an annotated method should be treated as the format string
            </param>
        </member>
        <member name="T:JetBrains.Annotations.StructuredMessageTemplateAttribute">
             <summary>
             Indicates that the marked parameter is a message template where placeholders are to be replaced by the following arguments
             in the order in which they appear
             </summary>
             <example><code>
             void LogInfo([StructuredMessageTemplate]string message, params object[] args) { /* do something */ }
            
             void Foo() {
               LogInfo("User created: {username}"); // Warning: Non-existing argument in format string
             }
             </code></example>
        </member>
        <member name="T:JetBrains.Annotations.ValueProviderAttribute">
             <summary>
             Use this annotation to specify a type that contains static or const fields
             with values for the annotated property/field/parameter.
             The specified type will be used to improve completion suggestions.
             </summary>
             <example><code>
             namespace TestNamespace
             {
               public class Constants
               {
                 public static int INT_CONST = 1;
                 public const string STRING_CONST = "1";
               }
            
               public class Class1
               {
                 [ValueProvider("TestNamespace.Constants")] public int myField;
                 public void Foo([ValueProvider("TestNamespace.Constants")] string str) { }
            
                 public void Test()
                 {
                   Foo(/*try completion here*/);//
                   myField = /*try completion here*/
                 }
               }
             }
             </code></example>
        </member>
        <member name="T:JetBrains.Annotations.ValueRangeAttribute">
            <summary>
            Indicates that the integral value falls into the specified interval.
            It's allowed to specify multiple non-intersecting intervals.
            Values of interval boundaries are inclusive.
            </summary>
            <example><code>
            void Foo([ValueRange(0, 100)] int value) {
              if (value == -1) { // Warning: Expression is always 'false'
                ...
              }
            }
            </code></example>
        </member>
        <member name="T:JetBrains.Annotations.NonNegativeValueAttribute">
            <summary>
            Indicates that the integral value never falls below zero.
            </summary>
            <example><code>
            void Foo([NonNegativeValue] int value) {
              if (value == -1) { // Warning: Expression is always 'false'
                ...
              }
            }
            </code></example>
        </member>
        <member name="T:JetBrains.Annotations.InvokerParameterNameAttribute">
            <summary>
            Indicates that the function argument should be a string literal and match
            one of the parameters of the caller function. This annotation is used for parameters
            like 'string paramName' parameter of the <see cref="T:System.ArgumentNullException"/> constructor.
            </summary>
            <example><code>
            void Foo(string param) {
              if (param == null)
                throw new ArgumentNullException("par"); // Warning: Cannot resolve symbol
            }
            </code></example>
        </member>
        <member name="T:JetBrains.Annotations.NotifyPropertyChangedInvocatorAttribute">
             <summary>
             Indicates that the method is contained in a type that implements
             <c>System.ComponentModel.INotifyPropertyChanged</c> interface and this method
             is used to notify that some property value changed.
             </summary>
             <remarks>
             The method should be non-static and conform to one of the supported signatures:
             <list>
             <item><c>NotifyChanged(string)</c></item>
             <item><c>NotifyChanged(params string[])</c></item>
             <item><c>NotifyChanged{T}(Expression{Func{T}})</c></item>
             <item><c>NotifyChanged{T,U}(Expression{Func{T,U}})</c></item>
             <item><c>SetProperty{T}(ref T, T, string)</c></item>
             </list>
             </remarks>
             <example><code>
             public class Foo : INotifyPropertyChanged {
               public event PropertyChangedEventHandler PropertyChanged;
            
               [NotifyPropertyChangedInvocator]
               protected virtual void NotifyChanged(string propertyName) { ... }
            
               string _name;
            
               public string Name {
                 get { return _name; }
                 set { _name = value; NotifyChanged("LastName"); /* Warning */ }
               }
             }
             </code>
             Examples of generated notifications:
             <list>
             <item><c>NotifyChanged("Property")</c></item>
             <item><c>NotifyChanged(() =&gt; Property)</c></item>
             <item><c>NotifyChanged((VM x) =&gt; x.Property)</c></item>
             <item><c>SetProperty(ref myField, value, "Property")</c></item>
             </list>
             </example>
        </member>
        <member name="T:JetBrains.Annotations.ContractAnnotationAttribute">
            <summary>
            Describes dependency between method input and output.
            </summary>
            <syntax>
            <p>Function Definition Table syntax:</p>
            <list>
            <item>FDT      ::= FDTRow [;FDTRow]*</item>
            <item>FDTRow   ::= Input =&gt; Output | Output &lt;= Input</item>
            <item>Input    ::= ParameterName: Value [, Input]*</item>
            <item>Output   ::= [ParameterName: Value]* {halt|stop|void|nothing|Value}</item>
            <item>Value    ::= true | false | null | notnull | canbenull</item>
            </list>
            If the method has a single input parameter, its name could be omitted.<br/>
            Using <c>halt</c> (or <c>void</c>/<c>nothing</c>, which is the same) for the method output
            means that the method doesn't return normally (throws or terminates the process).<br/>
            Value <c>canbenull</c> is only applicable for output parameters.<br/>
            You can use multiple <c>[ContractAnnotation]</c> for each FDT row, or use single attribute
            with rows separated by the semicolon. There is no notion of order rows, all rows are checked
            for applicability and applied per each program state tracked by the analysis engine.<br/>
            </syntax>
            <examples><list>
            <item><code>
            [ContractAnnotation("=&gt; halt")]
            public void TerminationMethod()
            </code></item>
            <item><code>
            [ContractAnnotation("null &lt;= param:null")] // reverse condition syntax
            public string GetName(string surname)
            </code></item>
            <item><code>
            [ContractAnnotation("s:null =&gt; true")]
            public bool IsNullOrEmpty(string s) // string.IsNullOrEmpty()
            </code></item>
            <item><code>
            // A method that returns null if the parameter is null,
            // and not null if the parameter is not null
            [ContractAnnotation("null =&gt; null; notnull =&gt; notnull")]
            public object Transform(object data)
            </code></item>
            <item><code>
            [ContractAnnotation("=&gt; true, result: notnull; =&gt; false, result: null")]
            public bool TryParse(string s, out Person result)
            </code></item>
            </list></examples>
        </member>
        <member name="T:JetBrains.Annotations.LocalizationRequiredAttribute">
            <summary>
            Indicates whether the marked element should be localized.
            </summary>
            <example><code>
            [LocalizationRequiredAttribute(true)]
            class Foo {
              string str = "my string"; // Warning: Localizable string
            }
            </code></example>
        </member>
        <member name="T:JetBrains.Annotations.CannotApplyEqualityOperatorAttribute">
             <summary>
             Indicates that the value of the marked type (or its derivatives)
             cannot be compared using '==' or '!=' operators and <c>Equals()</c>
             should be used instead. However, using '==' or '!=' for comparison
             with <c>null</c> is always permitted.
             </summary>
             <example><code>
             [CannotApplyEqualityOperator]
             class NoEquality { }
            
             class UsesNoEquality {
               void Test() {
                 var ca1 = new NoEquality();
                 var ca2 = new NoEquality();
                 if (ca1 != null) { // OK
                   bool condition = ca1 == ca2; // Warning
                 }
               }
             }
             </code></example>
        </member>
        <member name="T:JetBrains.Annotations.BaseTypeRequiredAttribute">
             <summary>
             When applied to a target attribute, specifies a requirement for any type marked
             with the target attribute to implement or inherit specific type or types.
             </summary>
             <example><code>
             [BaseTypeRequired(typeof(IComponent)] // Specify requirement
             class ComponentAttribute : Attribute { }
            
             [Component] // ComponentAttribute requires implementing IComponent interface
             class MyComponent : IComponent { }
             </code></example>
        </member>
        <member name="T:JetBrains.Annotations.UsedImplicitlyAttribute">
             <summary>
             Indicates that the marked symbol is used implicitly (e.g. via reflection, in external library),
             so this symbol will be ignored by usage-checking inspections. <br/>
             You can use <see cref="T:JetBrains.Annotations.ImplicitUseKindFlags"/> and <see cref="T:JetBrains.Annotations.ImplicitUseTargetFlags"/>
             to configure how this attribute is applied.
             </summary>
             <example><code>
             [UsedImplicitly]
             public class TypeConverter {}
            
             public class SummaryData
             {
               [UsedImplicitly(ImplicitUseKindFlags.InstantiatedWithFixedConstructorSignature)]
               public SummaryData() {}
             }
            
             [UsedImplicitly(ImplicitUseTargetFlags.WithInheritors | ImplicitUseTargetFlags.Default)]
             public interface IService {}
             </code></example>
        </member>
        <member name="T:JetBrains.Annotations.MeansImplicitUseAttribute">
            <summary>
            Can be applied to attributes, type parameters, and parameters of a type assignable from <see cref="T:System.Type"/> .
            When applied to an attribute, the decorated attribute behaves the same as <see cref="T:JetBrains.Annotations.UsedImplicitlyAttribute"/>.
            When applied to a type parameter or to a parameter of type <see cref="T:System.Type"/>,
            indicates that the corresponding type is used implicitly.
            </summary>
        </member>
        <member name="T:JetBrains.Annotations.ImplicitUseKindFlags">
            <summary>
            Specifies the details of implicitly used symbol when it is marked
            with <see cref="T:JetBrains.Annotations.MeansImplicitUseAttribute"/> or <see cref="T:JetBrains.Annotations.UsedImplicitlyAttribute"/>.
            </summary>
        </member>
        <member name="F:JetBrains.Annotations.ImplicitUseKindFlags.Access">
            <summary>Only entity marked with attribute considered used.</summary>
        </member>
        <member name="F:JetBrains.Annotations.ImplicitUseKindFlags.Assign">
            <summary>Indicates implicit assignment to a member.</summary>
        </member>
        <member name="F:JetBrains.Annotations.ImplicitUseKindFlags.InstantiatedWithFixedConstructorSignature">
            <summary>
            Indicates implicit instantiation of a type with fixed constructor signature.
            That means any unused constructor parameters won't be reported as such.
            </summary>
        </member>
        <member name="F:JetBrains.Annotations.ImplicitUseKindFlags.InstantiatedNoFixedConstructorSignature">
            <summary>Indicates implicit instantiation of a type.</summary>
        </member>
        <member name="T:JetBrains.Annotations.ImplicitUseTargetFlags">
            <summary>
            Specifies what is considered to be used implicitly when marked
            with <see cref="T:JetBrains.Annotations.MeansImplicitUseAttribute"/> or <see cref="T:JetBrains.Annotations.UsedImplicitlyAttribute"/>.
            </summary>
        </member>
        <member name="F:JetBrains.Annotations.ImplicitUseTargetFlags.Members">
            <summary>Members of the type marked with the attribute are considered used.</summary>
        </member>
        <member name="F:JetBrains.Annotations.ImplicitUseTargetFlags.WithInheritors">
            <summary> Inherited entities are considered used. </summary>
        </member>
        <member name="F:JetBrains.Annotations.ImplicitUseTargetFlags.WithMembers">
            <summary>Entity marked with the attribute and all its members considered used.</summary>
        </member>
        <member name="T:JetBrains.Annotations.PublicAPIAttribute">
            <summary>
            This attribute is intended to mark publicly available API,
            which should not be removed and so is treated as used.
            </summary>
        </member>
        <member name="T:JetBrains.Annotations.InstantHandleAttribute">
            <summary>
            Tells the code analysis engine if the parameter is completely handled when the invoked method is on stack.
            If the parameter is a delegate, indicates that delegate can only be invoked during method execution
            (the delegate can be invoked zero or multiple times, but not stored to some field and invoked later,
            when the containing method is no longer on the execution stack).
            If the parameter is an enumerable, indicates that it is enumerated while the method is executed.
            If <see cref="P:JetBrains.Annotations.InstantHandleAttribute.RequireAwait"/> is true, the attribute will only takes effect if the method invocation is located under the 'await' expression.
            </summary>
        </member>
        <member name="P:JetBrains.Annotations.InstantHandleAttribute.RequireAwait">
            <summary>
            Require the method invocation to be used under the 'await' expression for this attribute to take effect on code analysis engine.
            Can be used for delegate/enumerable parameters of 'async' methods.
            </summary>
        </member>
        <member name="T:JetBrains.Annotations.PureAttribute">
             <summary>
             Indicates that a method does not make any observable state changes.
             The same as <c>System.Diagnostics.Contracts.PureAttribute</c>.
             </summary>
             <example><code>
             [Pure] int Multiply(int x, int y) => x * y;
            
             void M() {
               Multiply(123, 42); // Warning: Return value of pure method is not used
             }
             </code></example>
        </member>
        <member name="T:JetBrains.Annotations.MustUseReturnValueAttribute">
            <summary>
            Indicates that the return value of the method invocation must be used.
            </summary>
            <remarks>
            Methods decorated with this attribute (in contrast to pure methods) might change state,
            but make no sense without using their return value. <br/>
            Similarly to <see cref="T:JetBrains.Annotations.PureAttribute"/>, this attribute
            will help to detect usages of the method when the return value is not used.
            Optionally, you can specify a message to use when showing warnings, e.g.
            <code>[MustUseReturnValue("Use the return value to...")]</code>.
            </remarks>
        </member>
        <member name="T:JetBrains.Annotations.RequireStaticDelegateAttribute">
            <summary>
            This annotation allows to enforce allocation-less usage patterns of delegates for performance-critical APIs.
            When this annotation is applied to the parameter of delegate type, IDE checks the input argument of this parameter:
            * When lambda expression or anonymous method is passed as an argument, IDE verifies that the passed closure
              has no captures of the containing local variables and the compiler is able to cache the delegate instance
              to avoid heap allocations. Otherwise the warning is produced.
            * IDE warns when method name or local function name is passed as an argument as this always results
              in heap allocation of the delegate instance.
            </summary>
            <remarks>
            In C# 9.0 code IDE would also suggest to annotate the anonymous function with 'static' modifier
            to make use of the similar analysis provided by the language/compiler.
            </remarks>
        </member>
        <member name="T:JetBrains.Annotations.ProvidesContextAttribute">
             <summary>
             Indicates the type member or parameter of some type, that should be used instead of all other ways
             to get the value of that type. This annotation is useful when you have some "context" value evaluated
             and stored somewhere, meaning that all other ways to get this value must be consolidated with existing one.
             </summary>
             <example><code>
             class Foo {
               [ProvidesContext] IBarService _barService = ...;
            
               void ProcessNode(INode node) {
                 DoSomething(node, node.GetGlobalServices().Bar);
                 //              ^ Warning: use value of '_barService' field
               }
             }
             </code></example>
        </member>
        <member name="T:JetBrains.Annotations.PathReferenceAttribute">
            <summary>
            Indicates that a parameter is a path to a file or a folder within a web project.
            Path can be relative or absolute, starting from web root (~).
            </summary>
        </member>
        <member name="T:JetBrains.Annotations.SourceTemplateAttribute">
            <summary>
            An extension method marked with this attribute is processed by code completion
            as a 'Source Template'. When the extension method is completed over some expression, its source code
            is automatically expanded like a template at call site.
            </summary>
            <remarks>
            Template method body can contain valid source code and/or special comments starting with '$'.
            Text inside these comments is added as source code when the template is applied. Template parameters
            can be used either as additional method parameters or as identifiers wrapped in two '$' signs.
            Use the <see cref="T:JetBrains.Annotations.MacroAttribute"/> attribute to specify macros for parameters.
            </remarks>
            <example>
            In this example, the 'forEach' method is a source template available over all values
            of enumerable types, producing ordinary C# 'foreach' statement and placing caret inside block:
            <code>
            [SourceTemplate]
            public static void forEach&lt;T&gt;(this IEnumerable&lt;T&gt; xs) {
              foreach (var x in xs) {
                 //$ $END$
              }
            }
            </code>
            </example>
        </member>
        <member name="T:JetBrains.Annotations.MacroAttribute">
            <summary>
            Allows specifying a macro for a parameter of a <see cref="T:JetBrains.Annotations.SourceTemplateAttribute">source template</see>.
            </summary>
            <remarks>
            You can apply the attribute on the whole method or on any of its additional parameters. The macro expression
            is defined in the <see cref="P:JetBrains.Annotations.MacroAttribute.Expression"/> property. When applied on a method, the target
            template parameter is defined in the <see cref="P:JetBrains.Annotations.MacroAttribute.Target"/> property. To apply the macro silently
            for the parameter, set the <see cref="P:JetBrains.Annotations.MacroAttribute.Editable"/> property value = -1.
            </remarks>
            <example>
            Applying the attribute on a source template method:
            <code>
            [SourceTemplate, Macro(Target = "item", Expression = "suggestVariableName()")]
            public static void forEach&lt;T&gt;(this IEnumerable&lt;T&gt; collection) {
              foreach (var item in collection) {
                //$ $END$
              }
            }
            </code>
            Applying the attribute on a template method parameter:
            <code>
            [SourceTemplate]
            public static void something(this Entity x, [Macro(Expression = "guid()", Editable = -1)] string newguid) {
              /*$ var $x$Id = "$newguid$" + x.ToString();
              x.DoSomething($x$Id); */
            }
            </code>
            </example>
        </member>
        <member name="P:JetBrains.Annotations.MacroAttribute.Expression">
            <summary>
            Allows specifying a macro that will be executed for a <see cref="T:JetBrains.Annotations.SourceTemplateAttribute">source template</see>
            parameter when the template is expanded.
            </summary>
        </member>
        <member name="P:JetBrains.Annotations.MacroAttribute.Editable">
            <summary>
            Allows specifying which occurrence of the target parameter becomes editable when the template is deployed.
            </summary>
            <remarks>
            If the target parameter is used several times in the template, only one occurrence becomes editable;
            other occurrences are changed synchronously. To specify the zero-based index of the editable occurrence,
            use values >= 0. To make the parameter non-editable when the template is expanded, use -1.
            </remarks>
        </member>
        <member name="P:JetBrains.Annotations.MacroAttribute.Target">
            <summary>
            Identifies the target parameter of a <see cref="T:JetBrains.Annotations.SourceTemplateAttribute">source template</see> if the
            <see cref="T:JetBrains.Annotations.MacroAttribute"/> is applied on a template method.
            </summary>
        </member>
        <member name="T:JetBrains.Annotations.CollectionAccessAttribute">
            <summary>
            Indicates how method, constructor invocation, or property access
            over collection type affects the contents of the collection.
            When applied to a return value of a method indicates if the returned collection
            is created exclusively for the caller (CollectionAccessType.UpdatedContent) or
            can be read/updated from outside (CollectionAccessType.Read | CollectionAccessType.UpdatedContent)
            Use <see cref="P:JetBrains.Annotations.CollectionAccessAttribute.CollectionAccessType"/> to specify the access type.
            </summary>
            <remarks>
            Using this attribute only makes sense if all collection methods are marked with this attribute.
            </remarks>
            <example><code>
            public class MyStringCollection : List&lt;string&gt;
            {
              [CollectionAccess(CollectionAccessType.Read)]
              public string GetFirstString()
              {
                return this.ElementAt(0);
              }
            }
            class Test
            {
              public void Foo()
              {
                // Warning: Contents of the collection is never updated
                var col = new MyStringCollection();
                string x = col.GetFirstString();
              }
            }
            </code></example>
        </member>
        <member name="T:JetBrains.Annotations.CollectionAccessType">
            <summary>
            Provides a value for the <see cref="T:JetBrains.Annotations.CollectionAccessAttribute"/> to define
            how the collection method invocation affects the contents of the collection.
            </summary>
        </member>
        <member name="F:JetBrains.Annotations.CollectionAccessType.None">
            <summary>Method does not use or modify content of the collection.</summary>
        </member>
        <member name="F:JetBrains.Annotations.CollectionAccessType.Read">
            <summary>Method only reads content of the collection but does not modify it.</summary>
        </member>
        <member name="F:JetBrains.Annotations.CollectionAccessType.ModifyExistingContent">
            <summary>Method can change content of the collection but does not add new elements.</summary>
        </member>
        <member name="F:JetBrains.Annotations.CollectionAccessType.UpdatedContent">
            <summary>Method can add new elements to the collection.</summary>
        </member>
        <member name="T:JetBrains.Annotations.AssertionMethodAttribute">
            <summary>
            Indicates that the marked method is assertion method, i.e. it halts the control flow if
            one of the conditions is satisfied. To set the condition, mark one of the parameters with
            <see cref="T:JetBrains.Annotations.AssertionConditionAttribute"/> attribute.
            </summary>
        </member>
        <member name="T:JetBrains.Annotations.AssertionConditionAttribute">
            <summary>
            Indicates the condition parameter of the assertion method. The method itself should be
            marked by <see cref="T:JetBrains.Annotations.AssertionMethodAttribute"/> attribute. The mandatory argument of
            the attribute is the assertion type.
            </summary>
        </member>
        <member name="T:JetBrains.Annotations.AssertionConditionType">
            <summary>
            Specifies assertion type. If the assertion method argument satisfies the condition,
            then the execution continues. Otherwise, execution is assumed to be halted.
            </summary>
        </member>
        <member name="F:JetBrains.Annotations.AssertionConditionType.IS_TRUE">
            <summary>Marked parameter should be evaluated to true.</summary>
        </member>
        <member name="F:JetBrains.Annotations.AssertionConditionType.IS_FALSE">
            <summary>Marked parameter should be evaluated to false.</summary>
        </member>
        <member name="F:JetBrains.Annotations.AssertionConditionType.IS_NULL">
            <summary>Marked parameter should be evaluated to null value.</summary>
        </member>
        <member name="F:JetBrains.Annotations.AssertionConditionType.IS_NOT_NULL">
            <summary>Marked parameter should be evaluated to not null value.</summary>
        </member>
        <member name="T:JetBrains.Annotations.TerminatesProgramAttribute">
            <summary>
            Indicates that the marked method unconditionally terminates control flow execution.
            For example, it could unconditionally throw exception.
            </summary>
        </member>
        <member name="T:JetBrains.Annotations.LinqTunnelAttribute">
            <summary>
            Indicates that the method is a pure LINQ method, with postponed enumeration (like Enumerable.Select,
            .Where). This annotation allows inference of [InstantHandle] annotation for parameters
            of delegate type by analyzing LINQ method chains.
            </summary>
        </member>
        <member name="T:JetBrains.Annotations.NoEnumerationAttribute">
             <summary>
             Indicates that IEnumerable passed as a parameter is not enumerated.
             Use this annotation to suppress the 'Possible multiple enumeration of IEnumerable' inspection.
             </summary>
             <example><code>
             static void ThrowIfNull&lt;T&gt;([NoEnumeration] T v, string n) where T : class
             {
               // custom check for null but no enumeration
             }
            
             void Foo(IEnumerable&lt;string&gt; values)
             {
               ThrowIfNull(values, nameof(values));
               var x = values.ToList(); // No warnings about multiple enumeration
             }
             </code></example>
        </member>
        <member name="T:JetBrains.Annotations.RegexPatternAttribute">
            <summary>
            Indicates that the marked parameter, field, or property is a regular expression pattern.
            </summary>
        </member>
        <member name="T:JetBrains.Annotations.InjectedLanguage">
            <summary>
            Language of injected code fragment inside marked by <see cref="T:JetBrains.Annotations.LanguageInjectionAttribute"/> string literal.
            </summary>
        </member>
        <member name="T:JetBrains.Annotations.LanguageInjectionAttribute">
            <summary>
            Indicates that the marked parameter, field, or property is accepting a string literal
            containing code fragment in a language specified by the <see cref="P:JetBrains.Annotations.LanguageInjectionAttribute.InjectedLanguage"/>.
            </summary>
            <example><code>
            void Foo([LanguageInjection(InjectedLanguage.CSS, Prefix = "body{", Suffix = "}")] string cssProps)
            {
              // cssProps should only contains a list of CSS properties
            }
            </code></example>
        </member>
        <member name="P:JetBrains.Annotations.LanguageInjectionAttribute.InjectedLanguage">
            <summary>Specify a language of injected code fragment.</summary>
        </member>
        <member name="P:JetBrains.Annotations.LanguageInjectionAttribute.Prefix">
            <summary>Specify a string that "precedes" injected string literal.</summary>
        </member>
        <member name="P:JetBrains.Annotations.LanguageInjectionAttribute.Suffix">
            <summary>Specify a string that "follows" injected string literal.</summary>
        </member>
        <member name="T:JetBrains.Annotations.NoReorderAttribute">
            <summary>
            Prevents the Member Reordering feature from tossing members of the marked class.
            </summary>
            <remarks>
            The attribute must be mentioned in your member reordering patterns.
            </remarks>
        </member>
        <member name="T:NLog.Common.AsyncContinuation">
            <summary>
            Asynchronous continuation delegate - function invoked at the end of asynchronous
            processing.
            </summary>
            <param name="exception">Exception during asynchronous processing or null if no exception
            was thrown.</param>
        </member>
        <member name="T:NLog.Common.AsyncHelpers">
            <summary>
            Helpers for asynchronous operations.
            </summary>
        </member>
        <member name="M:NLog.Common.AsyncHelpers.ForEachItemSequentially``1(System.Collections.Generic.IEnumerable{``0},NLog.Common.AsyncContinuation,NLog.Common.AsynchronousAction{``0})">
            <summary>
            Iterates over all items in the given collection and runs the specified action
            in sequence (each action executes only after the preceding one has completed without an error).
            </summary>
            <typeparam name="T">Type of each item.</typeparam>
            <param name="items">The items to iterate.</param>
            <param name="asyncContinuation">The asynchronous continuation to invoke once all items
            have been iterated.</param>
            <param name="action">The action to invoke for each item.</param>
        </member>
        <member name="M:NLog.Common.AsyncHelpers.Repeat(System.Int32,NLog.Common.AsyncContinuation,NLog.Common.AsynchronousAction)">
            <summary>
            Repeats the specified asynchronous action multiple times and invokes asynchronous continuation at the end.
            </summary>
            <param name="repeatCount">The repeat count.</param>
            <param name="asyncContinuation">The asynchronous continuation to invoke at the end.</param>
            <param name="action">The action to invoke.</param>
        </member>
        <member name="M:NLog.Common.AsyncHelpers.PrecededBy(NLog.Common.AsyncContinuation,NLog.Common.AsynchronousAction)">
            <summary>
            Modifies the continuation by pre-pending given action to execute just before it.
            </summary>
            <param name="asyncContinuation">The async continuation.</param>
            <param name="action">The action to pre-pend.</param>
            <returns>Continuation which will execute the given action before forwarding to the actual continuation.</returns>
        </member>
        <member name="M:NLog.Common.AsyncHelpers.WithTimeout(NLog.Common.AsyncContinuation,System.TimeSpan)">
            <summary>
            Attaches a timeout to a continuation which will invoke the continuation when the specified
            timeout has elapsed.
            </summary>
            <param name="asyncContinuation">The asynchronous continuation.</param>
            <param name="timeout">The timeout.</param>
            <returns>Wrapped continuation.</returns>
        </member>
        <member name="M:NLog.Common.AsyncHelpers.ForEachItemInParallel``1(System.Collections.Generic.IEnumerable{``0},NLog.Common.AsyncContinuation,NLog.Common.AsynchronousAction{``0})">
            <summary>
            Iterates over all items in the given collection and runs the specified action
            in parallel (each action executes on a thread from thread pool).
            </summary>
            <typeparam name="T">Type of each item.</typeparam>
            <param name="values">The items to iterate.</param>
            <param name="asyncContinuation">The asynchronous continuation to invoke once all items
            have been iterated.</param>
            <param name="action">The action to invoke for each item.</param>
        </member>
        <member name="M:NLog.Common.AsyncHelpers.RunSynchronously(NLog.Common.AsynchronousAction)">
            <summary>
            Runs the specified asynchronous action synchronously (blocks until the continuation has
            been invoked).
            </summary>
            <param name="action">The action.</param>
            <remarks>
            Using this method is not recommended because it will block the calling thread.
            </remarks>
        </member>
        <member name="M:NLog.Common.AsyncHelpers.PreventMultipleCalls(NLog.Common.AsyncContinuation)">
            <summary>
            Wraps the continuation with a guard which will only make sure that the continuation function
            is invoked only once.
            </summary>
            <param name="asyncContinuation">The asynchronous continuation.</param>
            <returns>Wrapped asynchronous continuation.</returns>
        </member>
        <member name="M:NLog.Common.AsyncHelpers.GetCombinedException(System.Collections.Generic.IList{System.Exception})">
            <summary>
            Gets the combined exception from all exceptions in the list.
            </summary>
            <param name="exceptions">The exceptions.</param>
            <returns>Combined exception or null if no exception was thrown.</returns>
        </member>
        <member name="M:NLog.Common.AsyncHelpers.WaitForDispose(System.Threading.Timer,System.TimeSpan)">
            <summary>
            Disposes the Timer, and waits for it to leave the Timer-callback-method
            </summary>
            <param name="timer">The Timer object to dispose</param>
            <param name="timeout">Timeout to wait (TimeSpan.Zero means dispose without waiting)</param>
            <returns>Timer disposed within timeout (true/false)</returns>
        </member>
        <member name="T:NLog.Common.AsynchronousAction">
            <summary>
            Asynchronous action.
            </summary>
            <param name="asyncContinuation">Continuation to be invoked at the end of action.</param>
        </member>
        <member name="T:NLog.Common.AsynchronousAction`1">
            <summary>
            Asynchronous action with one argument.
            </summary>
            <typeparam name="T">Type of the argument.</typeparam>
            <param name="argument">Argument to the action.</param>
            <param name="asyncContinuation">Continuation to be invoked at the end of action.</param>
        </member>
        <member name="T:NLog.Common.AsyncLogEventInfo">
            <summary>
            Represents the logging event with asynchronous continuation.
            </summary>
        </member>
        <member name="M:NLog.Common.AsyncLogEventInfo.#ctor(NLog.LogEventInfo,NLog.Common.AsyncContinuation)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Common.AsyncLogEventInfo"/> struct.
            </summary>
            <param name="logEvent">The log event.</param>
            <param name="continuation">The continuation.</param>
        </member>
        <member name="P:NLog.Common.AsyncLogEventInfo.LogEvent">
            <summary>
            Gets the log event.
            </summary>
        </member>
        <member name="P:NLog.Common.AsyncLogEventInfo.Continuation">
            <summary>
            Gets the continuation.
            </summary>
        </member>
        <member name="M:NLog.Common.AsyncLogEventInfo.op_Equality(NLog.Common.AsyncLogEventInfo,NLog.Common.AsyncLogEventInfo)">
            <summary>
            Implements the operator ==.
            </summary>
            <param name="eventInfo1">The event info1.</param>
            <param name="eventInfo2">The event info2.</param>
            <returns>The result of the operator.</returns>
        </member>
        <member name="M:NLog.Common.AsyncLogEventInfo.op_Inequality(NLog.Common.AsyncLogEventInfo,NLog.Common.AsyncLogEventInfo)">
            <summary>
            Implements the operator ==.
            </summary>
            <param name="eventInfo1">The event info1.</param>
            <param name="eventInfo2">The event info2.</param>
            <returns>The result of the operator.</returns>
        </member>
        <member name="M:NLog.Common.AsyncLogEventInfo.Equals(NLog.Common.AsyncLogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Common.AsyncLogEventInfo.Equals(System.Object)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Common.AsyncLogEventInfo.GetHashCode">
            <inheritdoc/>
        </member>
        <member name="T:NLog.Common.ConversionHelpers">
            <summary>
            String Conversion Helpers
            </summary>
        </member>
        <member name="M:NLog.Common.ConversionHelpers.TryParseEnum``1(System.String,``0@,``0)">
            <summary>
            Converts input string value into <see cref="T:System.Enum"/>. Parsing is case-insensitive.
            </summary>
            <param name="inputValue">Input value</param>
            <param name="resultValue">Output value</param>
            <param name="defaultValue">Default value</param>
            <returns>Returns false if the input value could not be parsed</returns>
        </member>
        <member name="M:NLog.Common.ConversionHelpers.TryParseEnum(System.String,System.Type,System.Object@)">
            <summary>
            Converts input string value into <see cref="T:System.Enum"/>. Parsing is case-insensitive.
            </summary>
            <param name="inputValue">Input value</param>
            <param name="enumType">The type of the enum</param>
            <param name="resultValue">Output value. Null if parse failed</param>
        </member>
        <member name="M:NLog.Common.ConversionHelpers.TryParseEnum``1(System.String,System.Boolean,``0@)">
            <summary>
            Converts the string representation of the name or numeric value of one or more enumerated constants to an equivalent enumerated object. A parameter specifies whether the operation is case-sensitive. The return value indicates whether the conversion succeeded.
            </summary>
            <typeparam name="TEnum">The enumeration type to which to convert value.</typeparam>
            <param name="inputValue">The string representation of the enumeration name or underlying value to convert.</param>
            <param name="ignoreCase"><c>true</c> to ignore case; <c>false</c> to consider case.</param>
            <param name="resultValue">When this method returns, result contains an object of type TEnum whose value is represented by value if the parse operation succeeds. If the parse operation fails, result contains the default value of the underlying type of TEnum. Note that this value need not be a member of the TEnum enumeration. This parameter is passed uninitialized.</param>
            <returns><c>true</c> if the value parameter was converted successfully; otherwise, <c>false</c>.</returns>
            <remarks>Wrapper because Enum.TryParse is not present in .net 3.5</remarks>
        </member>
        <member name="M:NLog.Common.ConversionHelpers.TryParseEnum_net3``1(System.String,System.Boolean,``0@)">
            <summary>
            Enum.TryParse implementation for .net 3.5
            </summary>
            <returns></returns>
            <remarks>Don't uses reflection</remarks>
        </member>
        <member name="T:NLog.Common.IInternalLoggerContext">
            <summary>
            Enables <see cref="T:NLog.Common.InternalLogger"/> to extract extra context details for <see cref="E:NLog.Common.InternalLogger.LogMessageReceived"/>
            </summary>
        </member>
        <member name="P:NLog.Common.IInternalLoggerContext.Name">
            <summary>
            Name of context
            </summary>
        </member>
        <member name="P:NLog.Common.IInternalLoggerContext.LogFactory">
            <summary>
            The current LogFactory next to LogManager
            </summary>
        </member>
        <member name="T:NLog.Common.InternalEventOccurredHandler">
            <summary>
            Handle Internal LogEvent written to the InternalLogger
            </summary>
            <remarks>
            Never use/call NLog Logger-objects when handling these internal events, as it will lead to deadlock / stackoverflow.
            </remarks>
        </member>
        <member name="T:NLog.Common.InternalLogEventArgs">
            <summary>
            Internal LogEvent details from <see cref="T:NLog.Common.InternalLogger"/>
            </summary>
        </member>
        <member name="P:NLog.Common.InternalLogEventArgs.Message">
            <summary>
            The rendered message
            </summary>
        </member>
        <member name="P:NLog.Common.InternalLogEventArgs.Level">
            <summary>
            The log level
            </summary>
        </member>
        <member name="P:NLog.Common.InternalLogEventArgs.Exception">
            <summary>
            The exception. Could be null.
            </summary>
        </member>
        <member name="P:NLog.Common.InternalLogEventArgs.SenderType">
            <summary>
            The type that triggered this internal log event, for example the FileTarget.
            This property is not always populated.
            </summary>
        </member>
        <member name="P:NLog.Common.InternalLogEventArgs.SenderName">
            <summary>
            The context name that triggered this internal log event, for example the name of the Target.
            This property is not always populated.
            </summary>
        </member>
        <member name="T:NLog.Common.InternalLogger">
             <summary>
             NLog internal logger.
            
             Writes to file, console or custom text writer (see <see cref="P:NLog.Common.InternalLogger.LogWriter"/>)
             </summary>
             <remarks>
             Don't use <see cref="M:NLog.Internal.ExceptionHelper.MustBeRethrown(System.Exception,NLog.Common.IInternalLoggerContext,System.String)"/> as that can lead to recursive calls - stackoverflow
             </remarks>
        </member>
        <member name="P:NLog.Common.InternalLogger.IsTraceEnabled">
            <summary>
            Gets a value indicating whether internal log includes Trace messages.
            </summary>
        </member>
        <member name="P:NLog.Common.InternalLogger.IsDebugEnabled">
            <summary>
            Gets a value indicating whether internal log includes Debug messages.
            </summary>
        </member>
        <member name="P:NLog.Common.InternalLogger.IsInfoEnabled">
            <summary>
            Gets a value indicating whether internal log includes Info messages.
            </summary>
        </member>
        <member name="P:NLog.Common.InternalLogger.IsWarnEnabled">
            <summary>
            Gets a value indicating whether internal log includes Warn messages.
            </summary>
        </member>
        <member name="P:NLog.Common.InternalLogger.IsErrorEnabled">
            <summary>
            Gets a value indicating whether internal log includes Error messages.
            </summary>
        </member>
        <member name="P:NLog.Common.InternalLogger.IsFatalEnabled">
            <summary>
            Gets a value indicating whether internal log includes Fatal messages.
            </summary>
        </member>
        <member name="M:NLog.Common.InternalLogger.Trace(System.String,System.Object[])">
            <summary>
            Logs the specified message without an <see cref="T:System.Exception"/> at the Trace level.
            </summary>
            <param name="message">Message which may include positional parameters.</param>
            <param name="args">Arguments to the message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Trace(System.String)">
            <summary>
            Logs the specified message without an <see cref="T:System.Exception"/> at the Trace level.
            </summary>
            <param name="message">Log message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Trace(System.Func{System.String})">
            <summary>
            Logs the specified message without an <see cref="T:System.Exception"/> at the Trace level.
            <paramref name="messageFunc"/> will be only called when logging is enabled for level  Trace.
            </summary>
            <param name="messageFunc">Function that returns the log message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Trace(System.Exception,System.String,System.Object[])">
            <summary>
            Logs the specified message with an <see cref="T:System.Exception"/> at the Trace level.
            </summary>
            <param name="ex">Exception to be logged.</param>
            <param name="message">Message which may include positional parameters.</param>
            <param name="args">Arguments to the message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Trace``1(System.String,``0)">
            <summary>
            Logs the specified message without an <see cref="T:System.Exception"/> at the Trace level.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <param name="message">Message which may include positional parameters.</param>
            <param name="arg0">Argument {0} to the message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Trace``2(System.String,``0,``1)">
            <summary>
            Logs the specified message without an <see cref="T:System.Exception"/> at the Trace level.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <param name="message">Message which may include positional parameters.</param>
            <param name="arg0">Argument {0} to the message.</param>
            <param name="arg1">Argument {1} to the message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Trace``3(System.String,``0,``1,``2)">
            <summary>
            Logs the specified message without an <see cref="T:System.Exception"/> at the Trace level.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <typeparam name="TArgument3">The type of the third argument.</typeparam>
            <param name="message">Message which may include positional parameters.</param>
            <param name="arg0">Argument {0} to the message.</param>
            <param name="arg1">Argument {1} to the message.</param>
            <param name="arg2">Argument {2} to the message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Trace(System.Exception,System.String)">
            <summary>
            Logs the specified message with an <see cref="T:System.Exception"/> at the Trace level.
            </summary>
            <param name="ex">Exception to be logged.</param>
            <param name="message">Log message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Trace(System.Exception,System.Func{System.String})">
            <summary>
            Logs the specified message with an <see cref="T:System.Exception"/> at the Trace level.
            <paramref name="messageFunc"/> will be only called when logging is enabled for level  Trace.
            </summary>
            <param name="ex">Exception to be logged.</param>
            <param name="messageFunc">Function that returns the log message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Debug(System.String,System.Object[])">
            <summary>
            Logs the specified message without an <see cref="T:System.Exception"/> at the Debug level.
            </summary>
            <param name="message">Message which may include positional parameters.</param>
            <param name="args">Arguments to the message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Debug(System.String)">
            <summary>
            Logs the specified message without an <see cref="T:System.Exception"/> at the Debug level.
            </summary>
            <param name="message">Log message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Debug(System.Func{System.String})">
            <summary>
            Logs the specified message without an <see cref="T:System.Exception"/> at the Debug level.
            <paramref name="messageFunc"/> will be only called when logging is enabled for level  Debug.
            </summary>
            <param name="messageFunc">Function that returns the log message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Debug(System.Exception,System.String,System.Object[])">
            <summary>
            Logs the specified message with an <see cref="T:System.Exception"/> at the Debug level.
            </summary>
            <param name="ex">Exception to be logged.</param>
            <param name="message">Message which may include positional parameters.</param>
            <param name="args">Arguments to the message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Debug``1(System.String,``0)">
            <summary>
            Logs the specified message without an <see cref="T:System.Exception"/> at the Trace level.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <param name="message">Message which may include positional parameters.</param>
            <param name="arg0">Argument {0} to the message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Debug``2(System.String,``0,``1)">
            <summary>
            Logs the specified message without an <see cref="T:System.Exception"/> at the Trace level.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <param name="message">Message which may include positional parameters.</param>
            <param name="arg0">Argument {0} to the message.</param>
            <param name="arg1">Argument {1} to the message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Debug``3(System.String,``0,``1,``2)">
            <summary>
            Logs the specified message without an <see cref="T:System.Exception"/> at the Trace level.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <typeparam name="TArgument3">The type of the third argument.</typeparam>
            <param name="message">Message which may include positional parameters.</param>
            <param name="arg0">Argument {0} to the message.</param>
            <param name="arg1">Argument {1} to the message.</param>
            <param name="arg2">Argument {2} to the message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Debug(System.Exception,System.String)">
            <summary>
            Logs the specified message with an <see cref="T:System.Exception"/> at the Debug level.
            </summary>
            <param name="ex">Exception to be logged.</param>
            <param name="message">Log message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Debug(System.Exception,System.Func{System.String})">
            <summary>
            Logs the specified message with an <see cref="T:System.Exception"/> at the Debug level.
            <paramref name="messageFunc"/> will be only called when logging is enabled for level  Debug.
            </summary>
            <param name="ex">Exception to be logged.</param>
            <param name="messageFunc">Function that returns the log message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Info(System.String,System.Object[])">
            <summary>
            Logs the specified message without an <see cref="T:System.Exception"/> at the Info level.
            </summary>
            <param name="message">Message which may include positional parameters.</param>
            <param name="args">Arguments to the message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Info(System.String)">
            <summary>
            Logs the specified message without an <see cref="T:System.Exception"/> at the Info level.
            </summary>
            <param name="message">Log message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Info(System.Func{System.String})">
            <summary>
            Logs the specified message without an <see cref="T:System.Exception"/> at the Info level.
            <paramref name="messageFunc"/> will be only called when logging is enabled for level  Info.
            </summary>
            <param name="messageFunc">Function that returns the log message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Info(System.Exception,System.String,System.Object[])">
            <summary>
            Logs the specified message with an <see cref="T:System.Exception"/> at the Info level.
            </summary>
            <param name="ex">Exception to be logged.</param>
            <param name="message">Message which may include positional parameters.</param>
            <param name="args">Arguments to the message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Info``1(System.String,``0)">
            <summary>
            Logs the specified message without an <see cref="T:System.Exception"/> at the Trace level.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <param name="message">Message which may include positional parameters.</param>
            <param name="arg0">Argument {0} to the message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Info``2(System.String,``0,``1)">
            <summary>
            Logs the specified message without an <see cref="T:System.Exception"/> at the Trace level.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <param name="message">Message which may include positional parameters.</param>
            <param name="arg0">Argument {0} to the message.</param>
            <param name="arg1">Argument {1} to the message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Info``3(System.String,``0,``1,``2)">
            <summary>
            Logs the specified message without an <see cref="T:System.Exception"/> at the Trace level.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <typeparam name="TArgument3">The type of the third argument.</typeparam>
            <param name="message">Message which may include positional parameters.</param>
            <param name="arg0">Argument {0} to the message.</param>
            <param name="arg1">Argument {1} to the message.</param>
            <param name="arg2">Argument {2} to the message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Info(System.Exception,System.String)">
            <summary>
            Logs the specified message with an <see cref="T:System.Exception"/> at the Info level.
            </summary>
            <param name="ex">Exception to be logged.</param>
            <param name="message">Log message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Info(System.Exception,System.Func{System.String})">
            <summary>
            Logs the specified message with an <see cref="T:System.Exception"/> at the Info level.
            <paramref name="messageFunc"/> will be only called when logging is enabled for level  Info.
            </summary>
            <param name="ex">Exception to be logged.</param>
            <param name="messageFunc">Function that returns the log message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Warn(System.String,System.Object[])">
            <summary>
            Logs the specified message without an <see cref="T:System.Exception"/> at the Warn level.
            </summary>
            <param name="message">Message which may include positional parameters.</param>
            <param name="args">Arguments to the message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Warn(System.String)">
            <summary>
            Logs the specified message without an <see cref="T:System.Exception"/> at the Warn level.
            </summary>
            <param name="message">Log message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Warn(System.Func{System.String})">
            <summary>
            Logs the specified message without an <see cref="T:System.Exception"/> at the Warn level.
            <paramref name="messageFunc"/> will be only called when logging is enabled for level  Warn.
            </summary>
            <param name="messageFunc">Function that returns the log message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Warn(System.Exception,System.String,System.Object[])">
            <summary>
            Logs the specified message with an <see cref="T:System.Exception"/> at the Warn level.
            </summary>
            <param name="ex">Exception to be logged.</param>
            <param name="message">Message which may include positional parameters.</param>
            <param name="args">Arguments to the message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Warn``1(System.String,``0)">
            <summary>
            Logs the specified message without an <see cref="T:System.Exception"/> at the Trace level.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <param name="message">Message which may include positional parameters.</param>
            <param name="arg0">Argument {0} to the message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Warn``2(System.String,``0,``1)">
            <summary>
            Logs the specified message without an <see cref="T:System.Exception"/> at the Trace level.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <param name="message">Message which may include positional parameters.</param>
            <param name="arg0">Argument {0} to the message.</param>
            <param name="arg1">Argument {1} to the message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Warn``3(System.String,``0,``1,``2)">
            <summary>
            Logs the specified message without an <see cref="T:System.Exception"/> at the Trace level.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <typeparam name="TArgument3">The type of the third argument.</typeparam>
            <param name="message">Message which may include positional parameters.</param>
            <param name="arg0">Argument {0} to the message.</param>
            <param name="arg1">Argument {1} to the message.</param>
            <param name="arg2">Argument {2} to the message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Warn(System.Exception,System.String)">
            <summary>
            Logs the specified message with an <see cref="T:System.Exception"/> at the Warn level.
            </summary>
            <param name="ex">Exception to be logged.</param>
            <param name="message">Log message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Warn(System.Exception,System.Func{System.String})">
            <summary>
            Logs the specified message with an <see cref="T:System.Exception"/> at the Warn level.
            <paramref name="messageFunc"/> will be only called when logging is enabled for level  Warn.
            </summary>
            <param name="ex">Exception to be logged.</param>
            <param name="messageFunc">Function that returns the log message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Error(System.String,System.Object[])">
            <summary>
            Logs the specified message without an <see cref="T:System.Exception"/> at the Error level.
            </summary>
            <param name="message">Message which may include positional parameters.</param>
            <param name="args">Arguments to the message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Error(System.String)">
            <summary>
            Logs the specified message without an <see cref="T:System.Exception"/> at the Error level.
            </summary>
            <param name="message">Log message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Error(System.Func{System.String})">
            <summary>
            Logs the specified message without an <see cref="T:System.Exception"/> at the Error level.
            <paramref name="messageFunc"/> will be only called when logging is enabled for level  Error.
            </summary>
            <param name="messageFunc">Function that returns the log message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Error(System.Exception,System.String,System.Object[])">
            <summary>
            Logs the specified message with an <see cref="T:System.Exception"/> at the Error level.
            </summary>
            <param name="ex">Exception to be logged.</param>
            <param name="message">Message which may include positional parameters.</param>
            <param name="args">Arguments to the message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Error``1(System.String,``0)">
            <summary>
            Logs the specified message without an <see cref="T:System.Exception"/> at the Trace level.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <param name="message">Message which may include positional parameters.</param>
            <param name="arg0">Argument {0} to the message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Error``2(System.String,``0,``1)">
            <summary>
            Logs the specified message without an <see cref="T:System.Exception"/> at the Trace level.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <param name="message">Message which may include positional parameters.</param>
            <param name="arg0">Argument {0} to the message.</param>
            <param name="arg1">Argument {1} to the message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Error``3(System.String,``0,``1,``2)">
            <summary>
            Logs the specified message without an <see cref="T:System.Exception"/> at the Trace level.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <typeparam name="TArgument3">The type of the third argument.</typeparam>
            <param name="message">Message which may include positional parameters.</param>
            <param name="arg0">Argument {0} to the message.</param>
            <param name="arg1">Argument {1} to the message.</param>
            <param name="arg2">Argument {2} to the message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Error(System.Exception,System.String)">
            <summary>
            Logs the specified message with an <see cref="T:System.Exception"/> at the Error level.
            </summary>
            <param name="ex">Exception to be logged.</param>
            <param name="message">Log message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Error(System.Exception,System.Func{System.String})">
            <summary>
            Logs the specified message with an <see cref="T:System.Exception"/> at the Error level.
            <paramref name="messageFunc"/> will be only called when logging is enabled for level  Error.
            </summary>
            <param name="ex">Exception to be logged.</param>
            <param name="messageFunc">Function that returns the log message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Fatal(System.String,System.Object[])">
            <summary>
            Logs the specified message without an <see cref="T:System.Exception"/> at the Fatal level.
            </summary>
            <param name="message">Message which may include positional parameters.</param>
            <param name="args">Arguments to the message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Fatal(System.String)">
            <summary>
            Logs the specified message without an <see cref="T:System.Exception"/> at the Fatal level.
            </summary>
            <param name="message">Log message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Fatal(System.Func{System.String})">
            <summary>
            Logs the specified message without an <see cref="T:System.Exception"/> at the Fatal level.
            <paramref name="messageFunc"/> will be only called when logging is enabled for level  Fatal.
            </summary>
            <param name="messageFunc">Function that returns the log message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Fatal(System.Exception,System.String,System.Object[])">
            <summary>
            Logs the specified message with an <see cref="T:System.Exception"/> at the Fatal level.
            </summary>
            <param name="ex">Exception to be logged.</param>
            <param name="message">Message which may include positional parameters.</param>
            <param name="args">Arguments to the message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Fatal``1(System.String,``0)">
            <summary>
            Logs the specified message without an <see cref="T:System.Exception"/> at the Trace level.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <param name="message">Message which may include positional parameters.</param>
            <param name="arg0">Argument {0} to the message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Fatal``2(System.String,``0,``1)">
            <summary>
            Logs the specified message without an <see cref="T:System.Exception"/> at the Trace level.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <param name="message">Message which may include positional parameters.</param>
            <param name="arg0">Argument {0} to the message.</param>
            <param name="arg1">Argument {1} to the message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Fatal``3(System.String,``0,``1,``2)">
            <summary>
            Logs the specified message without an <see cref="T:System.Exception"/> at the Trace level.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <typeparam name="TArgument3">The type of the third argument.</typeparam>
            <param name="message">Message which may include positional parameters.</param>
            <param name="arg0">Argument {0} to the message.</param>
            <param name="arg1">Argument {1} to the message.</param>
            <param name="arg2">Argument {2} to the message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Fatal(System.Exception,System.String)">
            <summary>
            Logs the specified message with an <see cref="T:System.Exception"/> at the Fatal level.
            </summary>
            <param name="ex">Exception to be logged.</param>
            <param name="message">Log message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Fatal(System.Exception,System.Func{System.String})">
            <summary>
            Logs the specified message with an <see cref="T:System.Exception"/> at the Fatal level.
            <paramref name="messageFunc"/> will be only called when logging is enabled for level  Fatal.
            </summary>
            <param name="ex">Exception to be logged.</param>
            <param name="messageFunc">Function that returns the log message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Reset">
            <summary>
            Set the config of the InternalLogger with defaults and config.
            </summary>
        </member>
        <member name="P:NLog.Common.InternalLogger.LogLevel">
            <summary>
            Gets or sets the minimal internal log level.
            </summary>
            <example>If set to <see cref="F:NLog.LogLevel.Info"/>, then messages of the levels <see cref="F:NLog.LogLevel.Info"/>, <see cref="F:NLog.LogLevel.Error"/> and <see cref="F:NLog.LogLevel.Fatal"/> will be written.</example>
        </member>
        <member name="P:NLog.Common.InternalLogger.LogToConsole">
            <summary>
            Gets or sets a value indicating whether internal messages should be written to the console output stream.
            </summary>
            <remarks>Your application must be a console application.</remarks>
        </member>
        <member name="P:NLog.Common.InternalLogger.LogToConsoleError">
            <summary>
            Gets or sets a value indicating whether internal messages should be written to the console error stream.
            </summary>
            <remarks>Your application must be a console application.</remarks>
        </member>
        <member name="P:NLog.Common.InternalLogger.LogToTrace">
            <summary>
            Obsolete and replaced by <see cref="P:NLog.Common.InternalLogger.LogWriter"/> with NLog v5.3.
            Gets or sets a value indicating whether internal messages should be written to the <see cref="N:System.Diagnostics"/>.Trace
            </summary>
        </member>
        <member name="P:NLog.Common.InternalLogger.LogFile">
            <summary>
            Gets or sets the file path of the internal log file.
            </summary>
            <remarks>A value of <see langword="null" /> value disables internal logging to a file.</remarks>
        </member>
        <member name="P:NLog.Common.InternalLogger.LogWriter">
            <summary>
            Gets or sets the text writer that will receive internal logs.
            </summary>
        </member>
        <member name="E:NLog.Common.InternalLogger.LogMessageReceived">
             <summary>
             Obsolete and replaced by <see cref="E:NLog.Common.InternalLogger.InternalEventOccurred"/> with NLog 5.3.
             Event written to the internal log.
             </summary>
             <remarks>
             EventHandler will only be triggered for events, where severity matches the configured <see cref="P:NLog.Common.InternalLogger.LogLevel"/>.
            
             Avoid using/calling NLog Logger-objects when handling these internal events, as it will lead to deadlock / stackoverflow.
             </remarks>
        </member>
        <member name="E:NLog.Common.InternalLogger.InternalEventOccurred">
             <summary>
             Internal LogEvent written to the InternalLogger
             </summary>
             <remarks>
             EventHandler will only be triggered for events, where severity matches the configured <see cref="P:NLog.Common.InternalLogger.LogLevel"/>.
            
             Never use/call NLog Logger-objects when handling these internal events, as it will lead to deadlock / stackoverflow.
             </remarks>
        </member>
        <member name="P:NLog.Common.InternalLogger.IncludeTimestamp">
            <summary>
            Gets or sets a value indicating whether timestamp should be included in internal log output.
            </summary>
        </member>
        <member name="P:NLog.Common.InternalLogger.ExceptionThrowWhenWriting">
            <summary>
            Is there an <see cref="T:System.Exception"/> thrown when writing the message?
            </summary>
        </member>
        <member name="M:NLog.Common.InternalLogger.Log(NLog.LogLevel,System.String,System.Object[])">
            <summary>
            Logs the specified message without an <see cref="T:System.Exception"/> at the specified level.
            </summary>
            <param name="level">Log level.</param>
            <param name="message">Message which may include positional parameters.</param>
            <param name="args">Arguments to the message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Log(NLog.LogLevel,System.String)">
            <summary>
            Logs the specified message without an <see cref="T:System.Exception"/> at the specified level.
            </summary>
            <param name="level">Log level.</param>
            <param name="message">Log message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Log(NLog.LogLevel,System.Func{System.String})">
            <summary>
            Logs the specified message without an <see cref="T:System.Exception"/> at the specified level.
            <paramref name="messageFunc"/> will be only called when logging is enabled for level <paramref name="level"/>.
            </summary>
            <param name="level">Log level.</param>
            <param name="messageFunc">Function that returns the log message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Log(System.Exception,NLog.LogLevel,System.Func{System.String})">
            <summary>
            Logs the specified message with an <see cref="T:System.Exception"/> at the specified level.
            <paramref name="messageFunc"/> will be only called when logging is enabled for level <paramref name="level"/>.
            </summary>
            <param name="ex">Exception to be logged.</param>
            <param name="level">Log level.</param>
            <param name="messageFunc">Function that returns the log message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Log(System.Exception,NLog.LogLevel,System.String,System.Object[])">
            <summary>
            Logs the specified message with an <see cref="T:System.Exception"/> at the specified level.
            </summary>
            <param name="ex">Exception to be logged.</param>
            <param name="level">Log level.</param>
            <param name="message">Message which may include positional parameters.</param>
            <param name="args">Arguments to the message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Log(System.Exception,NLog.LogLevel,System.String)">
            <summary>
            Logs the specified message with an <see cref="T:System.Exception"/> at the specified level.
            </summary>
            <param name="ex">Exception to be logged.</param>
            <param name="level">Log level.</param>
            <param name="message">Log message.</param>
        </member>
        <member name="M:NLog.Common.InternalLogger.Write(System.Exception,NLog.LogLevel,System.String,System.Object[])">
            <summary>
            Write to internallogger.
            </summary>
            <param name="ex">optional exception to be logged.</param>
            <param name="level">level</param>
            <param name="message">message</param>
            <param name="args">optional args for <paramref name="message"/></param>
        </member>
        <member name="M:NLog.Common.InternalLogger.CreateLogLine(System.Exception,NLog.LogLevel,System.String)">
            <summary>
            Create log line with timestamp, exception message etc (if configured)
            </summary>
        </member>
        <member name="M:NLog.Common.InternalLogger.IsSeriousException(System.Exception)">
            <summary>
            Determine if logging should be avoided because of exception type.
            </summary>
            <param name="exception">The exception to check.</param>
            <returns><c>true</c> if logging should be avoided; otherwise, <c>false</c>.</returns>
        </member>
        <member name="M:NLog.Common.InternalLogger.IsLogLevelEnabled(NLog.LogLevel)">
            <summary>
            Determine if logging is enabled for given LogLevel
            </summary>
            <param name="logLevel">The <see cref="P:NLog.Common.InternalLogger.LogLevel"/> for the log event.</param>
            <returns><c>true</c> if logging is enabled; otherwise, <c>false</c>.</returns>
        </member>
        <member name="M:NLog.Common.InternalLogger.HasActiveLoggers">
            <summary>
            Determine if logging is enabled.
            </summary>
            <returns><c>true</c> if logging is enabled; otherwise, <c>false</c>.</returns>
        </member>
        <member name="M:NLog.Common.InternalLogger.LogAssemblyVersion(System.Reflection.Assembly)">
            <summary>
            Logs the assembly version and file version of the given Assembly.
            </summary>
            <param name="assembly">The assembly to log.</param>
        </member>
        <member name="T:NLog.Common.InternalLoggerMessageEventArgs">
            <summary>
            A message has been written to the internal logger
            </summary>
        </member>
        <member name="P:NLog.Common.InternalLoggerMessageEventArgs.Message">
            <summary>
            The rendered message
            </summary>
        </member>
        <member name="P:NLog.Common.InternalLoggerMessageEventArgs.Level">
            <summary>
            The log level
            </summary>
        </member>
        <member name="P:NLog.Common.InternalLoggerMessageEventArgs.Exception">
            <summary>
            The exception. Could be null.
            </summary>
        </member>
        <member name="P:NLog.Common.InternalLoggerMessageEventArgs.SenderType">
            <summary>
            The type that triggered this internal log event, for example the FileTarget.
            This property is not always populated.
            </summary>
        </member>
        <member name="P:NLog.Common.InternalLoggerMessageEventArgs.SenderName">
            <summary>
            The context name that triggered this internal log event, for example the name of the Target.
            This property is not always populated.
            </summary>
        </member>
        <member name="T:NLog.Common.LogEventInfoBuffer">
            <summary>
            A cyclic buffer of <see cref="T:NLog.LogEventInfo"/> object.
            </summary>
        </member>
        <member name="M:NLog.Common.LogEventInfoBuffer.#ctor(System.Int32,System.Boolean,System.Int32)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Common.LogEventInfoBuffer" /> class.
            </summary>
            <param name="size">Buffer size.</param>
            <param name="growAsNeeded">Whether buffer should grow as it becomes full.</param>
            <param name="growLimit">The maximum number of items that the buffer can grow to.</param>
        </member>
        <member name="P:NLog.Common.LogEventInfoBuffer.Size">
            <summary>
            Gets the capacity of the buffer
            </summary>
        </member>
        <member name="P:NLog.Common.LogEventInfoBuffer.Count">
            <summary>
            Gets the number of items in the buffer
            </summary>
        </member>
        <member name="M:NLog.Common.LogEventInfoBuffer.Append(NLog.Common.AsyncLogEventInfo)">
            <summary>
            Adds the specified log event to the buffer.
            </summary>
            <param name="eventInfo">Log event.</param>
            <returns>The number of items in the buffer.</returns>
        </member>
        <member name="M:NLog.Common.LogEventInfoBuffer.GetEventsAndClear">
            <summary>
            Gets the array of events accumulated in the buffer and clears the buffer as one atomic operation.
            </summary>
            <returns>Events in the buffer.</returns>
        </member>
        <member name="T:NLog.Conditions.ConditionAndExpression">
            <summary>
            Condition <b>and</b> expression.
            </summary>
        </member>
        <member name="M:NLog.Conditions.ConditionAndExpression.#ctor(NLog.Conditions.ConditionExpression,NLog.Conditions.ConditionExpression)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Conditions.ConditionAndExpression" /> class.
            </summary>
            <param name="left">Left hand side of the AND expression.</param>
            <param name="right">Right hand side of the AND expression.</param>
        </member>
        <member name="P:NLog.Conditions.ConditionAndExpression.Left">
            <summary>
            Gets the left hand side of the AND expression.
            </summary>
        </member>
        <member name="P:NLog.Conditions.ConditionAndExpression.Right">
            <summary>
            Gets the right hand side of the AND expression.
            </summary>
        </member>
        <member name="M:NLog.Conditions.ConditionAndExpression.ToString">
            <summary>
            Returns a string representation of this expression.
            </summary>
            <returns>A concatenated '(Left) and (Right)' string.</returns>
        </member>
        <member name="M:NLog.Conditions.ConditionAndExpression.EvaluateNode(NLog.LogEventInfo)">
            <summary>
            Evaluates the expression by evaluating <see cref="P:NLog.Conditions.ConditionAndExpression.Left"/> and <see cref="P:NLog.Conditions.ConditionAndExpression.Right"/> recursively.
            </summary>
            <param name="context">Evaluation context.</param>
            <returns>The value of the conjunction operator.</returns>
        </member>
        <member name="T:NLog.Conditions.ConditionEvaluationException">
            <summary>
            Exception during evaluation of condition expression.
            </summary>
        </member>
        <member name="M:NLog.Conditions.ConditionEvaluationException.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Conditions.ConditionEvaluationException" /> class.
            </summary>
        </member>
        <member name="M:NLog.Conditions.ConditionEvaluationException.#ctor(System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Conditions.ConditionEvaluationException" /> class.
            </summary>
            <param name="message">The message.</param>
        </member>
        <member name="M:NLog.Conditions.ConditionEvaluationException.#ctor(System.String,System.Exception)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Conditions.ConditionEvaluationException" /> class.
            </summary>
            <param name="message">The message.</param>
            <param name="innerException">The inner exception.</param>
        </member>
        <member name="M:NLog.Conditions.ConditionEvaluationException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Conditions.ConditionEvaluationException" /> class.
            </summary>
            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param>
            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
            <exception cref="T:System.ArgumentNullException">
            The <paramref name="info"/> parameter is null.
            </exception>
            <exception cref="T:System.Runtime.Serialization.SerializationException">
            The class name is null or <see cref="P:System.Exception.HResult"/> is zero (0).
            </exception>
        </member>
        <member name="T:NLog.Conditions.ConditionExceptionExpression">
            <summary>
            Condition message expression (represented by the <b>exception</b> keyword).
            </summary>
        </member>
        <member name="M:NLog.Conditions.ConditionExceptionExpression.ToString">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Conditions.ConditionExceptionExpression.EvaluateNode(NLog.LogEventInfo)">
            <summary>
            Evaluates the current <see cref="P:NLog.LogEventInfo.Exception"/>.
            </summary>
            <param name="context">Evaluation context.</param>
            <returns>The <see cref="P:NLog.LogEventInfo.Exception"/> object.</returns>
        </member>
        <member name="T:NLog.Conditions.ConditionExpression">
            <summary>
            Base class for representing nodes in condition expression trees.
            </summary>
            <seealso href="https://github.com/NLog/NLog/wiki/Conditions">Documentation on NLog Wiki</seealso>
        </member>
        <member name="M:NLog.Conditions.ConditionExpression.op_Implicit(System.String)~NLog.Conditions.ConditionExpression">
            <summary>
            Converts condition text to a condition expression tree.
            </summary>
            <param name="conditionExpressionText">Condition text to be converted.</param>
            <returns>Condition expression tree.</returns>
        </member>
        <member name="M:NLog.Conditions.ConditionExpression.Evaluate(NLog.LogEventInfo)">
            <summary>
            Evaluates the expression.
            </summary>
            <param name="context">Evaluation context.</param>
            <returns>Expression result.</returns>
        </member>
        <member name="M:NLog.Conditions.ConditionExpression.ToString">
            <summary>
            Returns a string representation of the expression.
            </summary>
        </member>
        <member name="M:NLog.Conditions.ConditionExpression.EvaluateNode(NLog.LogEventInfo)">
            <summary>
            Evaluates the expression.
            </summary>
            <param name="context">Evaluation context.</param>
            <returns>Expression result.</returns>
        </member>
        <member name="T:NLog.Conditions.ConditionLayoutExpression">
            <summary>
            Condition layout expression (represented by a string literal
            with embedded ${}).
            </summary>
        </member>
        <member name="M:NLog.Conditions.ConditionLayoutExpression.#ctor(NLog.Layouts.SimpleLayout)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Conditions.ConditionLayoutExpression" /> class.
            </summary>
            <param name="layout">The layout.</param>
        </member>
        <member name="P:NLog.Conditions.ConditionLayoutExpression.Layout">
            <summary>
            Gets the layout.
            </summary>
            <value>The layout.</value>
        </member>
        <member name="M:NLog.Conditions.ConditionLayoutExpression.ToString">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Conditions.ConditionLayoutExpression.EvaluateNode(NLog.LogEventInfo)">
            <summary>
            Evaluates the expression by rendering the formatted output from
            the <see cref="P:NLog.Conditions.ConditionLayoutExpression.Layout"/>
            </summary>
            <param name="context">Evaluation context.</param>
            <returns>The output rendered from the layout.</returns>
        </member>
        <member name="T:NLog.Conditions.ConditionLevelExpression">
            <summary>
            Condition level expression (represented by the <b>level</b> keyword).
            </summary>
        </member>
        <member name="M:NLog.Conditions.ConditionLevelExpression.ToString">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Conditions.ConditionLevelExpression.EvaluateNode(NLog.LogEventInfo)">
            <summary>
            Evaluates to the current log level.
            </summary>
            <param name="context">Evaluation context.</param>
            <returns>The <see cref="T:NLog.LogLevel"/> object representing current log level.</returns>
        </member>
        <member name="T:NLog.Conditions.ConditionLiteralExpression">
            <summary>
            Condition literal expression (numeric, <b>LogLevel.XXX</b>, <b>true</b> or <b>false</b>).
            </summary>
        </member>
        <member name="M:NLog.Conditions.ConditionLiteralExpression.#ctor(System.Object)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Conditions.ConditionLiteralExpression" /> class.
            </summary>
            <param name="literalValue">Literal value.</param>
        </member>
        <member name="P:NLog.Conditions.ConditionLiteralExpression.LiteralValue">
            <summary>
            Gets the literal value.
            </summary>
            <value>The literal value.</value>
        </member>
        <member name="M:NLog.Conditions.ConditionLiteralExpression.ToString">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Conditions.ConditionLiteralExpression.EvaluateNode(NLog.LogEventInfo)">
            <summary>
            Evaluates the expression.
            </summary>
            <param name="context">Evaluation context. Ignored.</param>
            <returns>The literal value as passed in the constructor.</returns>
        </member>
        <member name="T:NLog.Conditions.ConditionLoggerNameExpression">
            <summary>
            Condition logger name expression (represented by the <b>logger</b> keyword).
            </summary>
        </member>
        <member name="M:NLog.Conditions.ConditionLoggerNameExpression.ToString">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Conditions.ConditionLoggerNameExpression.EvaluateNode(NLog.LogEventInfo)">
            <summary>
            Evaluates to the logger name.
            </summary>
            <param name="context">Evaluation context.</param>
            <returns>The logger name.</returns>
        </member>
        <member name="T:NLog.Conditions.ConditionMessageExpression">
            <summary>
            Condition message expression (represented by the <b>message</b> keyword).
            </summary>
        </member>
        <member name="M:NLog.Conditions.ConditionMessageExpression.ToString">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Conditions.ConditionMessageExpression.EvaluateNode(NLog.LogEventInfo)">
            <summary>
            Evaluates to the logger message.
            </summary>
            <param name="context">Evaluation context.</param>
            <returns>The logger message.</returns>
        </member>
        <member name="T:NLog.Conditions.ConditionMethodAttribute">
            <summary>
            Marks class as a log event Condition and assigns a name to it.
            </summary>
        </member>
        <member name="M:NLog.Conditions.ConditionMethodAttribute.#ctor(System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Conditions.ConditionMethodAttribute" /> class.
            </summary>
            <param name="name">Condition method name.</param>
        </member>
        <member name="P:NLog.Conditions.ConditionMethodExpression.MethodParameters">
            <summary>
            Gets the method parameters
            </summary>
        </member>
        <member name="M:NLog.Conditions.ConditionMethodExpression.EvaluateNode(NLog.LogEventInfo)">
            <inheritdoc />
        </member>
        <member name="M:NLog.Conditions.ConditionMethodExpression.ToString">
            <inheritdoc/>
        </member>
        <member name="T:NLog.Conditions.ConditionMethods">
            <summary>
            A bunch of utility methods (mostly predicates) which can be used in
            condition expressions. Partially inspired by XPath 1.0.
            </summary>
        </member>
        <member name="M:NLog.Conditions.ConditionMethods.Equals2(System.Object,System.Object)">
            <summary>
            Compares two values for equality.
            </summary>
            <param name="firstValue">The first value.</param>
            <param name="secondValue">The second value.</param>
            <returns><b>true</b> when two objects are equal, <b>false</b> otherwise.</returns>
        </member>
        <member name="M:NLog.Conditions.ConditionMethods.Equals2(System.String,System.String,System.Boolean)">
            <summary>
            Compares two strings for equality.
            </summary>
            <param name="firstValue">The first string.</param>
            <param name="secondValue">The second string.</param>
            <param name="ignoreCase">Optional. If <c>true</c>, case is ignored; if <c>false</c> (default), case is significant.</param>
            <returns><b>true</b> when two strings are equal, <b>false</b> otherwise.</returns>
        </member>
        <member name="M:NLog.Conditions.ConditionMethods.Contains(System.String,System.String,System.Boolean)">
            <summary>
            Gets or sets a value indicating whether the second string is a substring of the first one.
            </summary>
            <param name="haystack">The first string.</param>
            <param name="needle">The second string.</param>
            <param name="ignoreCase">Optional. If <c>true</c> (default), case is ignored; if <c>false</c>, case is significant.</param>
            <returns><b>true</b> when the second string is a substring of the first string, <b>false</b> otherwise.</returns>
        </member>
        <member name="M:NLog.Conditions.ConditionMethods.StartsWith(System.String,System.String,System.Boolean)">
            <summary>
            Gets or sets a value indicating whether the second string is a prefix of the first one.
            </summary>
            <param name="haystack">The first string.</param>
            <param name="needle">The second string.</param>
            <param name="ignoreCase">Optional. If <c>true</c> (default), case is ignored; if <c>false</c>, case is significant.</param>
            <returns><b>true</b> when the second string is a prefix of the first string, <b>false</b> otherwise.</returns>
        </member>
        <member name="M:NLog.Conditions.ConditionMethods.EndsWith(System.String,System.String,System.Boolean)">
            <summary>
            Gets or sets a value indicating whether the second string is a suffix of the first one.
            </summary>
            <param name="haystack">The first string.</param>
            <param name="needle">The second string.</param>
            <param name="ignoreCase">Optional. If <c>true</c> (default), case is ignored; if <c>false</c>, case is significant.</param>
            <returns><b>true</b> when the second string is a prefix of the first string, <b>false</b> otherwise.</returns>
        </member>
        <member name="M:NLog.Conditions.ConditionMethods.Length(System.String)">
            <summary>
            Returns the length of a string.
            </summary>
            <param name="text">A string whose lengths is to be evaluated.</param>
            <returns>The length of the string.</returns>
        </member>
        <member name="M:NLog.Conditions.ConditionMethods.RegexMatches(System.String,System.String,System.String)">
            <summary>
            Indicates whether the specified regular expression finds a match in the specified input string.
            </summary>
            <param name="input">The string to search for a match.</param>
            <param name="pattern">The regular expression pattern to match.</param>
            <param name="options">A string consisting of the desired options for the test. The possible values are those of the <see cref="T:System.Text.RegularExpressions.RegexOptions"/> separated by commas.</param>
            <returns>true if the regular expression finds a match; otherwise, false.</returns>
        </member>
        <member name="M:NLog.Conditions.ConditionMethods.ParseRegexOptions(System.String)">
             <summary>
            
             </summary>
             <param name="options"></param>
             <returns></returns>
        </member>
        <member name="T:NLog.Conditions.ConditionMethodsAttribute">
            <summary>
            Marks the class as containing condition methods.
            </summary>
        </member>
        <member name="T:NLog.Conditions.ConditionNotExpression">
            <summary>
            Condition <b>not</b> expression.
            </summary>
        </member>
        <member name="M:NLog.Conditions.ConditionNotExpression.#ctor(NLog.Conditions.ConditionExpression)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Conditions.ConditionNotExpression" /> class.
            </summary>
            <param name="expression">The expression.</param>
        </member>
        <member name="P:NLog.Conditions.ConditionNotExpression.Expression">
            <summary>
            Gets the expression to be negated.
            </summary>
            <value>The expression.</value>
        </member>
        <member name="M:NLog.Conditions.ConditionNotExpression.ToString">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Conditions.ConditionNotExpression.EvaluateNode(NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.Conditions.ConditionOrExpression">
            <summary>
            Condition <b>or</b> expression.
            </summary>
        </member>
        <member name="M:NLog.Conditions.ConditionOrExpression.#ctor(NLog.Conditions.ConditionExpression,NLog.Conditions.ConditionExpression)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Conditions.ConditionOrExpression" /> class.
            </summary>
            <param name="left">Left hand side of the OR expression.</param>
            <param name="right">Right hand side of the OR expression.</param>
        </member>
        <member name="P:NLog.Conditions.ConditionOrExpression.LeftExpression">
            <summary>
            Gets the left expression.
            </summary>
            <value>The left expression.</value>
        </member>
        <member name="P:NLog.Conditions.ConditionOrExpression.RightExpression">
            <summary>
            Gets the right expression.
            </summary>
            <value>The right expression.</value>
        </member>
        <member name="M:NLog.Conditions.ConditionOrExpression.ToString">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Conditions.ConditionOrExpression.EvaluateNode(NLog.LogEventInfo)">
            <summary>
            Evaluates the expression by evaluating <see cref="P:NLog.Conditions.ConditionOrExpression.LeftExpression"/> and <see cref="P:NLog.Conditions.ConditionOrExpression.RightExpression"/> recursively.
            </summary>
            <param name="context">Evaluation context.</param>
            <returns>The value of the alternative operator.</returns>
        </member>
        <member name="T:NLog.Conditions.ConditionParseException">
            <summary>
            Exception during parsing of condition expression.
            </summary>
        </member>
        <member name="M:NLog.Conditions.ConditionParseException.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Conditions.ConditionParseException" /> class.
            </summary>
        </member>
        <member name="M:NLog.Conditions.ConditionParseException.#ctor(System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Conditions.ConditionParseException" /> class.
            </summary>
            <param name="message">The message.</param>
        </member>
        <member name="M:NLog.Conditions.ConditionParseException.#ctor(System.String,System.Exception)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Conditions.ConditionParseException" /> class.
            </summary>
            <param name="message">The message.</param>
            <param name="innerException">The inner exception.</param>
        </member>
        <member name="M:NLog.Conditions.ConditionParseException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Conditions.ConditionParseException" /> class.
            </summary>
            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param>
            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
            <exception cref="T:System.ArgumentNullException">
            The <paramref name="info"/> parameter is null.
            </exception>
            <exception cref="T:System.Runtime.Serialization.SerializationException">
            The class name is null or <see cref="P:System.Exception.HResult"/> is zero (0).
            </exception>
        </member>
        <member name="T:NLog.Conditions.ConditionParser">
            <summary>
            Condition parser. Turns a string representation of condition expression
            into an expression tree.
            </summary>
        </member>
        <member name="M:NLog.Conditions.ConditionParser.#ctor(NLog.Internal.SimpleStringReader,NLog.Config.ConfigurationItemFactory)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Conditions.ConditionParser"/> class.
            </summary>
            <param name="stringReader">The string reader.</param>
            <param name="configurationItemFactory">Instance of <see cref="T:NLog.Config.ConfigurationItemFactory"/> used to resolve references to condition methods and layout renderers.</param>
        </member>
        <member name="M:NLog.Conditions.ConditionParser.ParseExpression(System.String)">
            <summary>
            Parses the specified condition string and turns it into
            <see cref="T:NLog.Conditions.ConditionExpression"/> tree.
            </summary>
            <param name="expressionText">The expression to be parsed.</param>
            <returns>The root of the expression syntax tree which can be used to get the value of the condition in a specified context.</returns>
        </member>
        <member name="M:NLog.Conditions.ConditionParser.ParseExpression(System.String,NLog.Config.ConfigurationItemFactory)">
            <summary>
            Parses the specified condition string and turns it into
            <see cref="T:NLog.Conditions.ConditionExpression"/> tree.
            </summary>
            <param name="expressionText">The expression to be parsed.</param>
            <param name="configurationItemFactories">Instance of <see cref="T:NLog.Config.ConfigurationItemFactory"/> used to resolve references to condition methods and layout renderers.</param>
            <returns>The root of the expression syntax tree which can be used to get the value of the condition in a specified context.</returns>
        </member>
        <member name="M:NLog.Conditions.ConditionParser.ParseExpression(NLog.Internal.SimpleStringReader,NLog.Config.ConfigurationItemFactory)">
            <summary>
            Parses the specified condition string and turns it into
            <see cref="T:NLog.Conditions.ConditionExpression"/> tree.
            </summary>
            <param name="stringReader">The string reader.</param>
            <param name="configurationItemFactories">Instance of <see cref="T:NLog.Config.ConfigurationItemFactory"/> used to resolve references to condition methods and layout renderers.</param>
            <returns>
            The root of the expression syntax tree which can be used to get the value of the condition in a specified context.
            </returns>
        </member>
        <member name="M:NLog.Conditions.ConditionParser.TryPlainKeywordToExpression(System.String,NLog.Conditions.ConditionExpression@)">
            <summary>
            Try stringed keyword to <see cref="T:NLog.Conditions.ConditionExpression"/>
            </summary>
            <param name="keyword"></param>
            <param name="expression"></param>
            <returns>success?</returns>
        </member>
        <member name="M:NLog.Conditions.ConditionParser.ParseNumber(System.Boolean)">
            <summary>
            Parse number
            </summary>
            <param name="negative">negative number? minus should be parsed first.</param>
            <returns></returns>
        </member>
        <member name="T:NLog.Conditions.ConditionRelationalExpression">
            <summary>
            Condition relational (<b>==</b>, <b>!=</b>, <b>&lt;</b>, <b>&lt;=</b>,
            <b>&gt;</b> or <b>&gt;=</b>) expression.
            </summary>
        </member>
        <member name="M:NLog.Conditions.ConditionRelationalExpression.#ctor(NLog.Conditions.ConditionExpression,NLog.Conditions.ConditionExpression,NLog.Conditions.ConditionRelationalOperator)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Conditions.ConditionRelationalExpression" /> class.
            </summary>
            <param name="leftExpression">The left expression.</param>
            <param name="rightExpression">The right expression.</param>
            <param name="relationalOperator">The relational operator.</param>
        </member>
        <member name="P:NLog.Conditions.ConditionRelationalExpression.LeftExpression">
            <summary>
            Gets the left expression.
            </summary>
            <value>The left expression.</value>
        </member>
        <member name="P:NLog.Conditions.ConditionRelationalExpression.RightExpression">
            <summary>
            Gets the right expression.
            </summary>
            <value>The right expression.</value>
        </member>
        <member name="P:NLog.Conditions.ConditionRelationalExpression.RelationalOperator">
            <summary>
            Gets the relational operator.
            </summary>
            <value>The operator.</value>
        </member>
        <member name="M:NLog.Conditions.ConditionRelationalExpression.ToString">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Conditions.ConditionRelationalExpression.EvaluateNode(NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Conditions.ConditionRelationalExpression.Compare(System.Object,System.Object,NLog.Conditions.ConditionRelationalOperator)">
            <summary>
            Compares the specified values using specified relational operator.
            </summary>
            <param name="leftValue">The first value.</param>
            <param name="rightValue">The second value.</param>
            <param name="relationalOperator">The relational operator.</param>
            <returns>Result of the given relational operator.</returns>
        </member>
        <member name="M:NLog.Conditions.ConditionRelationalExpression.PromoteTypes(System.Object@,System.Object@)">
            <summary>
            Promote values to the type needed for the comparison, e.g. parse a string to int.
            </summary>
            <param name="leftValue"></param>
            <param name="rightValue"></param>
        </member>
        <member name="M:NLog.Conditions.ConditionRelationalExpression.TryPromoteType(System.Object@,System.Type)">
            <summary>
            Promotes <paramref name="val"/> to type
            </summary>
            <param name="val"></param>
            <param name="type1"></param>
            <returns>success?</returns>
        </member>
        <member name="M:NLog.Conditions.ConditionRelationalExpression.TryPromoteTypes(System.Object@,System.Type,System.Object@,System.Type)">
            <summary>
            Try to promote both values. First try to promote <paramref name="val1"/> to <paramref name="type1"/>,
             when failed, try <paramref name="val2"/> to <paramref name="type2"/>.
            </summary>
            <returns></returns>
        </member>
        <member name="M:NLog.Conditions.ConditionRelationalExpression.GetOrder(System.Type)">
            <summary>
            Get the order for the type for comparison.
            </summary>
            <param name="type1"></param>
            <returns>index, 0 to max int. Lower is first</returns>
        </member>
        <member name="F:NLog.Conditions.ConditionRelationalExpression.TypePromoteOrder">
            <summary>
            Dictionary from type to index. Lower index should be tested first.
            </summary>
        </member>
        <member name="M:NLog.Conditions.ConditionRelationalExpression.BuildTypeOrderDictionary">
            <summary>
            Build the dictionary needed for the order of the types.
            </summary>
            <returns></returns>
        </member>
        <member name="M:NLog.Conditions.ConditionRelationalExpression.GetOperatorString">
            <summary>
            Get the string representing the current <see cref="T:NLog.Conditions.ConditionRelationalOperator"/>
            </summary>
            <returns></returns>
        </member>
        <member name="T:NLog.Conditions.ConditionRelationalOperator">
            <summary>
            Relational operators used in conditions.
            </summary>
        </member>
        <member name="F:NLog.Conditions.ConditionRelationalOperator.Equal">
            <summary>
            Equality (==).
            </summary>
        </member>
        <member name="F:NLog.Conditions.ConditionRelationalOperator.NotEqual">
            <summary>
            Inequality (!=).
            </summary>
        </member>
        <member name="F:NLog.Conditions.ConditionRelationalOperator.Less">
            <summary>
            Less than (&lt;).
            </summary>
        </member>
        <member name="F:NLog.Conditions.ConditionRelationalOperator.Greater">
            <summary>
            Greater than (&gt;).
            </summary>
        </member>
        <member name="F:NLog.Conditions.ConditionRelationalOperator.LessOrEqual">
            <summary>
            Less than or equal (&lt;=).
            </summary>
        </member>
        <member name="F:NLog.Conditions.ConditionRelationalOperator.GreaterOrEqual">
            <summary>
            Greater than or equal (&gt;=).
            </summary>
        </member>
        <member name="T:NLog.Conditions.ConditionTokenizer">
            <summary>
            Hand-written tokenizer for conditions.
            </summary>
        </member>
        <member name="M:NLog.Conditions.ConditionTokenizer.#ctor(NLog.Internal.SimpleStringReader)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Conditions.ConditionTokenizer"/> class.
            </summary>
            <param name="stringReader">The string reader.</param>
        </member>
        <member name="M:NLog.Conditions.ConditionTokenizer.Expect(NLog.Conditions.ConditionTokenType)">
            <summary>
            Asserts current token type and advances to the next token.
            </summary>
            <param name="tokenType">Expected token type.</param>
            <remarks>If token type doesn't match, an exception is thrown.</remarks>
        </member>
        <member name="M:NLog.Conditions.ConditionTokenizer.EatKeyword">
            <summary>
            Asserts that current token is a keyword and returns its value and advances to the next token.
            </summary>
            <returns>Keyword value.</returns>
        </member>
        <member name="M:NLog.Conditions.ConditionTokenizer.IsKeyword(System.String)">
            <summary>
            Gets or sets a value indicating whether current keyword is equal to the specified value.
            </summary>
            <param name="keyword">The keyword.</param>
            <returns>
            A value of <c>true</c> if current keyword is equal to the specified value; otherwise, <c>false</c>.
            </returns>
        </member>
        <member name="M:NLog.Conditions.ConditionTokenizer.IsEOF">
            <summary>
            Gets or sets a value indicating whether the tokenizer has reached the end of the token stream.
            </summary>
            <returns>
            A value of <c>true</c> if the tokenizer has reached the end of the token stream; otherwise, <c>false</c>.
            </returns>
        </member>
        <member name="M:NLog.Conditions.ConditionTokenizer.IsNumber">
            <summary>
            Gets or sets a value indicating whether current token is a number.
            </summary>
            <returns>
            A value of <c>true</c> if current token is a number; otherwise, <c>false</c>.
            </returns>
        </member>
        <member name="M:NLog.Conditions.ConditionTokenizer.IsToken(NLog.Conditions.ConditionTokenType)">
            <summary>
            Gets or sets a value indicating whether the specified token is of specified type.
            </summary>
            <param name="tokenType">The token type.</param>
            <returns>
            A value of <c>true</c> if current token is of specified type; otherwise, <c>false</c>.
            </returns>
        </member>
        <member name="M:NLog.Conditions.ConditionTokenizer.GetNextToken">
            <summary>
            Gets the next token and sets <see cref="P:NLog.Conditions.ConditionTokenizer.TokenType"/> and <see cref="P:NLog.Conditions.ConditionTokenizer.TokenValue"/> properties.
            </summary>
        </member>
        <member name="M:NLog.Conditions.ConditionTokenizer.TryGetComparisonToken(System.Char)">
            <summary>
            Try the comparison tokens (greater, smaller, greater-equals, smaller-equals)
            </summary>
            <param name="ch">current char</param>
            <returns>is match</returns>
        </member>
        <member name="M:NLog.Conditions.ConditionTokenizer.TryGetLogicalToken(System.Char)">
            <summary>
            Try the logical tokens (and, or, not, equals)
            </summary>
            <param name="ch">current char</param>
            <returns>is match</returns>
        </member>
        <member name="T:NLog.Conditions.ConditionTokenizer.CharToTokenType">
            <summary>
            Mapping between characters and token types for punctuations.
            </summary>
        </member>
        <member name="M:NLog.Conditions.ConditionTokenizer.CharToTokenType.#ctor(System.Char,NLog.Conditions.ConditionTokenType)">
            <summary>
            Initializes a new instance of the CharToTokenType struct.
            </summary>
            <param name="character">The character.</param>
            <param name="tokenType">Type of the token.</param>
        </member>
        <member name="T:NLog.Conditions.ConditionTokenType">
            <summary>
            Token types for condition expressions.
            </summary>
        </member>
        <member name="T:NLog.Config.AdvancedAttribute">
            <summary>
            Marks the class or a member as advanced. Advanced classes and members are hidden by
            default in generated documentation.
            </summary>
        </member>
        <member name="M:NLog.Config.AdvancedAttribute.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Config.AdvancedAttribute" /> class.
            </summary>
        </member>
        <member name="T:NLog.Config.AppDomainFixedOutputAttribute">
             <summary>
             Identifies that the output of layout or layout render does not change for the lifetime of the current appdomain.
             </summary>
             <remarks>
            
             Implementors must have the [ThreadAgnostic] attribute
            
             A layout(renderer) could be converted to a literal when:
              - The layout and all layout properties are SimpleLayout or [AppDomainFixedOutput]
            
             Recommendation: Apply this attribute to a layout or layout-renderer which have the result only changes by properties of type Layout.
             </remarks>
        </member>
        <member name="T:NLog.Config.ArrayParameterAttribute">
            <summary>
            Used to mark configurable parameters which are arrays.
            Specifies the mapping between XML elements and .NET types.
            </summary>
        </member>
        <member name="M:NLog.Config.ArrayParameterAttribute.#ctor(System.Type,System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Config.ArrayParameterAttribute" /> class.
            </summary>
            <param name="itemType">The type of the array item.</param>
            <param name="elementName">The XML element name that represents the item.</param>
        </member>
        <member name="P:NLog.Config.ArrayParameterAttribute.ItemType">
            <summary>
            Gets the .NET type of the array item.
            </summary>
        </member>
        <member name="P:NLog.Config.ArrayParameterAttribute.ElementName">
            <summary>
            Gets the XML element name.
            </summary>
        </member>
        <member name="M:NLog.Config.AssemblyExtensionLoader.LoadAssemblyFromPath(System.String,System.String)">
            <summary>
            Load from url
            </summary>
            <param name="assemblyFileName">file or path, including .dll</param>
            <param name="baseDirectory">basepath, optional</param>
            <returns></returns>
        </member>
        <member name="M:NLog.Config.AssemblyExtensionLoader.LoadAssemblyFromName(System.String)">
            <summary>
            Load from url
            </summary>
        </member>
        <member name="T:NLog.Config.AssemblyExtensionTypes">
            <summary>
            Provides logging interface and utility functions.
            </summary>
        </member>
        <member name="T:NLog.Config.AssemblyLoadingEventArgs">
            <summary>
            Obsolete since dynamic assembly loading is not compatible with publish as trimmed application.
            Event notification about trying to load assembly with NLog extensions.
            </summary>
        </member>
        <member name="M:NLog.Config.AssemblyLoadingEventArgs.#ctor(System.Reflection.Assembly)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Config.AssemblyLoadingEventArgs" /> class.
            </summary>
            <param name="assembly">Assembly that have been loaded</param>
        </member>
        <member name="P:NLog.Config.AssemblyLoadingEventArgs.Assembly">
            <summary>
            The assembly that is trying to load.
            </summary>
        </member>
        <member name="T:NLog.Config.ConfigSectionHandler">
            <summary>
            Represents NLog ConfigSection for loading <see cref="T:NLog.Config.XmlLoggingConfiguration"/> from app.config / web.config
            </summary>
            <remarks><code>
            &lt;configSections&gt;
              &lt;section name=&quot;NLog&quot; type=&quot;NLog.Config.ConfigSectionHandler, NLog&quot; /&gt;
            &lt;/configSections&gt;
            </code></remarks>
        </member>
        <member name="P:NLog.Config.ConfigSectionHandler.AppConfig">
            <summary>
            Gets the default <see cref="T:NLog.Config.LoggingConfiguration" /> object by parsing
            the application configuration file (<c>app.exe.config</c>).
            </summary>
        </member>
        <member name="M:NLog.Config.ConfigSectionHandler.DeserializeElement(System.Xml.XmlReader,System.Boolean)">
            <summary>
            Overriding base implementation to just store <see cref="T:System.Xml.XmlReader"/>
            of the relevant app.config section.
            </summary>
            <param name="reader">The XmlReader that reads from the configuration file.</param>
            <param name="serializeCollectionKey">true to serialize only the collection key properties; otherwise, false.</param>
        </member>
        <member name="M:NLog.Config.ConfigSectionHandler.GetRuntimeObject">
            <summary>
            Override base implementation to return a <see cref="T:NLog.Config.LoggingConfiguration"/> object
            for <see cref="M:System.Configuration.ConfigurationManager.GetSection(System.String)"/>
            instead of the <see cref="T:NLog.Config.ConfigSectionHandler"/> instance.
            </summary>
            <returns>
            A <see cref="T:NLog.Config.LoggingConfiguration"/> instance, that has been deserialized from app.config.
            </returns>
        </member>
        <member name="T:NLog.Config.ConfigurationItemCreator">
            <summary>
            Obsolete since dynamic tyope loading is not compatible with publish as trimmed application.
            Constructs a new instance the configuration item (target, layout, layout renderer, etc.) given its type.
            </summary>
            <param name="itemType">Type of the item.</param>
            <returns>Created object of the specified type.</returns>
        </member>
        <member name="T:NLog.Config.ConfigurationItemFactory">
             <summary>
             Provides registration information for named items (targets, layouts, layout renderers, etc.)
            
             Supports creating item-instance from their type-alias, when parsing NLog configuration
             </summary>
        </member>
        <member name="E:NLog.Config.ConfigurationItemFactory.AssemblyLoading">
            <summary>
            Obsolete since dynamic assembly loading is not compatible with publish as trimmed application.
            Called before the assembly with NLog extensions is being loaded.
            </summary>
        </member>
        <member name="M:NLog.Config.ConfigurationItemFactory.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Config.ConfigurationItemFactory"/> class.
            </summary>
        </member>
        <member name="M:NLog.Config.ConfigurationItemFactory.#ctor(System.Reflection.Assembly[])">
            <summary>
            Obsolete since dynamic assembly loading is not compatible with publish as trimmed application.
            Initializes a new instance of the <see cref="T:NLog.Config.ConfigurationItemFactory"/> class.
            </summary>
            <param name="assemblies">The assemblies to scan for named items.</param>
        </member>
        <member name="P:NLog.Config.ConfigurationItemFactory.Default">
            <summary>
            Gets or sets default singleton instance of <see cref="T:NLog.Config.ConfigurationItemFactory"/>.
            </summary>
            <remarks>
            This property implements lazy instantiation so that the <see cref="T:NLog.Config.ConfigurationItemFactory"/> is not built before
            the internal logger is configured.
            </remarks>
        </member>
        <member name="P:NLog.Config.ConfigurationItemFactory.TargetFactory">
            <summary>
            Gets the <see cref="T:NLog.Targets.Target"/> factory.
            </summary>
        </member>
        <member name="P:NLog.Config.ConfigurationItemFactory.LayoutFactory">
            <summary>
            Gets the <see cref="T:NLog.Layouts.Layout"/> factory.
            </summary>
        </member>
        <member name="P:NLog.Config.ConfigurationItemFactory.LayoutRendererFactory">
            <summary>
            Gets the <see cref="T:NLog.LayoutRenderers.LayoutRenderer"/> factory.
            </summary>
        </member>
        <member name="P:NLog.Config.ConfigurationItemFactory.AmbientRendererFactory">
            <summary>
            Gets the ambient property factory.
            </summary>
        </member>
        <member name="P:NLog.Config.ConfigurationItemFactory.FilterFactory">
            <summary>
            Gets the <see cref="T:NLog.Filters.Filter"/> factory.
            </summary>
        </member>
        <member name="P:NLog.Config.ConfigurationItemFactory.TimeSourceFactory">
            <summary>
            Gets the <see cref="T:NLog.Time.TimeSource"/> factory.
            </summary>
        </member>
        <member name="P:NLog.Config.ConfigurationItemFactory.CreateInstance">
            <summary>
            Obsolete and replaced by <see cref="M:NLog.SetupBuilderExtensions.SetupExtensions(NLog.Config.ISetupBuilder,System.Action{NLog.Config.ISetupExtensionsBuilder})"/> with NLog v5.2.
            Gets or sets the creator delegate used to instantiate configuration objects.
            </summary>
            <remarks>
            By overriding this property, one can enable dependency injection or interception for created objects.
            </remarks>
        </member>
        <member name="P:NLog.Config.ConfigurationItemFactory.Targets">
            <summary>
            Obsolete and replaced by <see cref="M:NLog.SetupBuilderExtensions.SetupExtensions(NLog.Config.ISetupBuilder,System.Action{NLog.Config.ISetupExtensionsBuilder})"/> with NLog v5.2.
            Gets the <see cref="T:NLog.Targets.Target"/> factory.
            </summary>
            <value>The target factory.</value>
        </member>
        <member name="P:NLog.Config.ConfigurationItemFactory.Layouts">
            <summary>
            Obsolete and replaced by <see cref="M:NLog.SetupBuilderExtensions.SetupExtensions(NLog.Config.ISetupBuilder,System.Action{NLog.Config.ISetupExtensionsBuilder})"/> with NLog v5.2.
            Gets the <see cref="T:NLog.Layouts.Layout"/> factory.
            </summary>
            <value>The layout factory.</value>
        </member>
        <member name="P:NLog.Config.ConfigurationItemFactory.LayoutRenderers">
            <summary>
            Obsolete and replaced by <see cref="M:NLog.SetupBuilderExtensions.SetupExtensions(NLog.Config.ISetupBuilder,System.Action{NLog.Config.ISetupExtensionsBuilder})"/> with NLog v5.2.
            Gets the <see cref="T:NLog.LayoutRenderers.LayoutRenderer"/> factory.
            </summary>
            <value>The layout renderer factory.</value>
        </member>
        <member name="P:NLog.Config.ConfigurationItemFactory.AmbientProperties">
            <summary>
            Obsolete and replaced by <see cref="M:NLog.SetupBuilderExtensions.SetupExtensions(NLog.Config.ISetupBuilder,System.Action{NLog.Config.ISetupExtensionsBuilder})"/> with NLog v5.2.
            Gets the ambient property factory.
            </summary>
            <value>The ambient property factory.</value>
        </member>
        <member name="P:NLog.Config.ConfigurationItemFactory.Filters">
            <summary>
            Obsolete and replaced by <see cref="M:NLog.SetupBuilderExtensions.SetupExtensions(NLog.Config.ISetupBuilder,System.Action{NLog.Config.ISetupExtensionsBuilder})"/> with NLog v5.2.
            Gets the <see cref="T:NLog.Filters.Filter"/> factory.
            </summary>
            <value>The filter factory.</value>
        </member>
        <member name="P:NLog.Config.ConfigurationItemFactory.TimeSources">
            <summary>
            Obsolete and replaced by <see cref="M:NLog.SetupBuilderExtensions.SetupExtensions(NLog.Config.ISetupBuilder,System.Action{NLog.Config.ISetupExtensionsBuilder})"/> with NLog v5.2.
            Gets the time source factory.
            </summary>
            <value>The time source factory.</value>
        </member>
        <member name="P:NLog.Config.ConfigurationItemFactory.ConditionMethods">
            <summary>
            Obsolete and replaced by <see cref="M:NLog.SetupBuilderExtensions.SetupExtensions(NLog.Config.ISetupBuilder,System.Action{NLog.Config.ISetupExtensionsBuilder})"/> with NLog v5.2.
            Gets the condition method factory.
            </summary>
            <value>The condition method factory.</value>
        </member>
        <member name="P:NLog.Config.ConfigurationItemFactory.JsonConverter">
            <summary>
            Obsolete and replaced by <see cref="M:NLog.SetupSerializationBuilderExtensions.RegisterJsonConverter(NLog.Config.ISetupSerializationBuilder,NLog.IJsonConverter)"/> with NLog v5.2.
            Gets or sets the JSON serializer to use with <see cref="T:NLog.Layouts.JsonLayout"/>
            </summary>
        </member>
        <member name="P:NLog.Config.ConfigurationItemFactory.ValueFormatter">
            <summary>
            Obsolete and replaced by <see cref="M:NLog.SetupSerializationBuilderExtensions.RegisterValueFormatter(NLog.Config.ISetupSerializationBuilder,NLog.IValueFormatter)"/> with NLog v5.2.
            Gets or sets the string serializer to use with <see cref="P:NLog.LogEventInfo.MessageTemplateParameters"/>
            </summary>
        </member>
        <member name="P:NLog.Config.ConfigurationItemFactory.PropertyTypeConverter">
            <summary>
            Obsolete and replaced by <see cref="M:NLog.SetupBuilderExtensions.SetupExtensions(NLog.Config.ISetupBuilder,System.Action{NLog.Config.ISetupExtensionsBuilder})"/> with NLog v5.2.
            Gets or sets the parameter converter to use with <see cref="T:NLog.Targets.TargetWithContext"/> or <see cref="T:NLog.Layouts.Layout`1"/>
            </summary>
        </member>
        <member name="P:NLog.Config.ConfigurationItemFactory.ParseMessageTemplates">
            <summary>
            Perform message template parsing and formatting of LogEvent messages (True = Always, False = Never, Null = Auto Detect)
            </summary>
            <remarks>
            - Null (Auto Detect) : NLog-parser checks <see cref="P:NLog.LogEventInfo.Message"/> for positional parameters, and will then fallback to string.Format-rendering.
            - True: Always performs the parsing of <see cref="P:NLog.LogEventInfo.Message"/> and rendering of <see cref="P:NLog.LogEventInfo.FormattedMessage"/> using the NLog-parser (Allows custom formatting with <see cref="P:NLog.Config.ConfigurationItemFactory.ValueFormatter"/>)
            - False: Always performs parsing and rendering using string.Format (Fastest if not using structured logging)
            </remarks>
        </member>
        <member name="M:NLog.Config.ConfigurationItemFactory.RegisterItemsFromAssembly(System.Reflection.Assembly)">
            <summary>
            Obsolete since dynamic assembly loading is not compatible with publish as trimmed application.
            Registers named items from the assembly.
            </summary>
            <param name="assembly">The assembly.</param>
        </member>
        <member name="M:NLog.Config.ConfigurationItemFactory.RegisterItemsFromAssembly(System.Reflection.Assembly,System.String)">
            <summary>
            Obsolete since dynamic assembly loading is not compatible with publish as trimmed application.
            Registers named items from the assembly.
            </summary>
            <param name="assembly">The assembly.</param>
            <param name="itemNamePrefix">Item name prefix.</param>
        </member>
        <member name="M:NLog.Config.ConfigurationItemFactory.PreloadAssembly(System.Type[])">
            <summary>
            Obsolete since dynamic assembly loading is not compatible with publish as trimmed application.
            Call Preload for NLogPackageLoader
            </summary>
            <remarks>
            Every package could implement a class "NLogPackageLoader" (namespace not important) with the public static method "Preload" (no arguments)
            This method will be called just before registering all items in the assembly.
            </remarks>
            <param name="typesToScan"></param>
        </member>
        <member name="M:NLog.Config.ConfigurationItemFactory.CallPreload(System.Type)">
            <summary>
            Call the Preload method for <paramref name="type"/>. The Preload method must be static.
            </summary>
            <param name="type"></param>
        </member>
        <member name="M:NLog.Config.ConfigurationItemFactory.Clear">
            <summary>
            Clears the contents of all factories.
            </summary>
        </member>
        <member name="M:NLog.Config.ConfigurationItemFactory.RegisterType(System.Type,System.String)">
            <summary>
            Obsolete since dynamic type loading is not compatible with publish as trimmed application.
            Registers the type.
            </summary>
            <param name="type">The type to register.</param>
            <param name="itemNamePrefix">The item name prefix.</param>
        </member>
        <member name="M:NLog.Config.ConfigurationItemFactory.BuildDefaultFactory">
            <summary>
            Builds the default configuration item factory.
            </summary>
            <returns>Default factory.</returns>
        </member>
        <member name="M:NLog.Config.ConfigurationItemFactory.RegisterExternalItems">
            <summary>
            Registers items in using late-bound types, so that we don't need a reference to the dll.
            </summary>
        </member>
        <member name="T:NLog.Config.DefaultParameterAttribute">
            <summary>
            Attribute used to mark the default parameters for layout renderers.
            </summary>
        </member>
        <member name="M:NLog.Config.DefaultParameterAttribute.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Config.DefaultParameterAttribute" /> class.
            </summary>
        </member>
        <member name="T:NLog.Config.DynamicLogLevelFilter">
            <summary>
            Dynamic filtering with a positive list of enabled levels
            </summary>
        </member>
        <member name="T:NLog.Config.DynamicRangeLevelFilter">
            <summary>
            Dynamic filtering with a minlevel and maxlevel range
            </summary>
        </member>
        <member name="T:NLog.Config.ExceptionRenderingFormat">
            <summary>
            Format of the exception output to the specific target.
            </summary>
        </member>
        <member name="F:NLog.Config.ExceptionRenderingFormat.Message">
            <summary>
            Appends the Message of an Exception to the specified target.
            </summary>
        </member>
        <member name="F:NLog.Config.ExceptionRenderingFormat.Type">
            <summary>
            Appends the type of an Exception to the specified target.
            </summary>
        </member>
        <member name="F:NLog.Config.ExceptionRenderingFormat.ShortType">
            <summary>
            Appends the short type of an Exception to the specified target.
            </summary>
        </member>
        <member name="F:NLog.Config.ExceptionRenderingFormat.ToString">
            <summary>
            Appends the result of calling ToString() on an Exception to the specified target.
            </summary>
        </member>
        <member name="F:NLog.Config.ExceptionRenderingFormat.Method">
            <summary>
            Appends the method name from Exception's stack trace to the specified target.
            </summary>
        </member>
        <member name="F:NLog.Config.ExceptionRenderingFormat.StackTrace">
            <summary>
            Appends the stack trace from an Exception to the specified target.
            </summary>
        </member>
        <member name="F:NLog.Config.ExceptionRenderingFormat.Data">
            <summary>
            Appends the contents of an Exception's Data property to the specified target.
            </summary>
        </member>
        <member name="F:NLog.Config.ExceptionRenderingFormat.Serialize">
            <summary>
            Destructure the exception (usually into JSON)
            </summary>
        </member>
        <member name="F:NLog.Config.ExceptionRenderingFormat.Source">
            <summary>
            Appends the <see cref="P:System.Exception.Source"/> from the application or the object that caused the error.
            </summary>
        </member>
        <member name="F:NLog.Config.ExceptionRenderingFormat.HResult">
            <summary>
            Appends the <see cref="P:System.Exception.HResult"/> from the application or the object that caused the error.
            </summary>
        </member>
        <member name="F:NLog.Config.ExceptionRenderingFormat.Properties">
            <summary>
            Appends any additional properties that specific type of Exception might have.
            </summary>
        </member>
        <member name="T:NLog.Config.Factory`2">
            <summary>
            Factory for class-based items.
            </summary>
            <typeparam name="TBaseType">The base type of each item.</typeparam>
            <typeparam name="TAttributeType">The type of the attribute used to annotate items.</typeparam>
        </member>
        <member name="M:NLog.Config.Factory`2.ScanTypes(System.Type[],System.String,System.String)">
            <summary>
            Scans the assembly.
            </summary>
            <param name="types">The types to scan.</param>
            <param name="assemblyName">The assembly name for the types.</param>
            <param name="itemNamePrefix">The prefix.</param>
        </member>
        <member name="M:NLog.Config.Factory`2.RegisterType(System.Type,System.String)">
            <summary>
            Registers the type.
            </summary>
            <param name="type">The type to register.</param>
            <param name="itemNamePrefix">The item name prefix.</param>
        </member>
        <member name="M:NLog.Config.Factory`2.RegisterNamedType(System.String,System.String)">
            <summary>
            Registers the item based on a type name.
            </summary>
            <param name="itemName">Name of the item.</param>
            <param name="typeName">Name of the type.</param>
        </member>
        <member name="M:NLog.Config.Factory`2.Clear">
            <summary>
            Clears the contents of the factory.
            </summary>
        </member>
        <member name="M:NLog.Config.Factory`2.NLog#Config#INamedItemFactory{TBaseType,System#Type}#RegisterDefinition(System.String,System.Type)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Config.Factory`2.TryGetDefinition(System.String,System.Type@)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Config.Factory`2.TryCreateInstance(System.String,`0@)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Config.Factory`2.NLog#Config#INamedItemFactory{TBaseType,System#Type}#CreateInstance(System.String)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.Config.LayoutRendererFactory">
            <summary>
            Factory specialized for <see cref="T:NLog.LayoutRenderers.LayoutRenderer"/>s.
            </summary>
        </member>
        <member name="M:NLog.Config.LayoutRendererFactory.Clear">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Config.LayoutRendererFactory.RegisterFuncLayout(System.String,NLog.LayoutRenderers.FuncLayoutRenderer)">
            <summary>
            Register a layout renderer with a callback function.
            </summary>
            <param name="itemName">Name of the layoutrenderer, without ${}.</param>
            <param name="renderer">the renderer that renders the value.</param>
        </member>
        <member name="M:NLog.Config.LayoutRendererFactory.TryCreateInstance(System.String,NLog.LayoutRenderers.LayoutRenderer@)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.Config.IFactory">
            <summary>
            Factory of named items (such as <see cref="T:NLog.Targets.Target"/>, <see cref="T:NLog.Layouts.Layout"/>, <see cref="T:NLog.LayoutRenderers.LayoutRenderer"/>, etc.).
            </summary>
        </member>
        <member name="T:NLog.Config.IFactory`1">
            <summary>
            Factory of named items (such as <see cref="T:NLog.Targets.Target"/>, <see cref="T:NLog.Layouts.Layout"/>, <see cref="T:NLog.LayoutRenderers.LayoutRenderer"/>, etc.).
            </summary>
        </member>
        <member name="M:NLog.Config.IFactory`1.RegisterType``1(System.String)">
            <summary>
            Registers type-creation with type-alias
            </summary>
        </member>
        <member name="M:NLog.Config.IFactory`1.TryCreateInstance(System.String,`0@)">
            <summary>
            Tries to create an item instance with type-alias
            </summary>
            <returns>True if instance was created successfully, false otherwise.</returns>
        </member>
        <member name="T:NLog.Config.IIncludeContext">
            <summary>
            Include context properties
            </summary>
        </member>
        <member name="P:NLog.Config.IIncludeContext.IncludeEventProperties">
            <summary>
            Gets or sets the option to include all properties from the log events
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Config.IIncludeContext.IncludeScopeProperties">
            <summary>
            Gets or sets whether to include the contents of the <see cref="T:NLog.ScopeContext"/> properties-dictionary.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Config.IIncludeContext.IncludeScopeNested">
            <summary>
            Gets or sets whether to include the contents of the <see cref="T:NLog.ScopeContext"/> nested-state-stack.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Config.IInitializeSucceeded.InitializeSucceeded">
            <summary>
            Did the Initialize Succeeded? <c>true</c>= success, <c>false</c>= error, <c>null</c> = initialize not started yet.
            </summary>
        </member>
        <member name="T:NLog.Config.IInstallable">
            <summary>
            Implemented by objects which support installation and uninstallation.
            </summary>
        </member>
        <member name="M:NLog.Config.IInstallable.Install(NLog.Config.InstallationContext)">
            <summary>
            Performs installation which requires administrative permissions.
            </summary>
            <param name="installationContext">The installation context.</param>
        </member>
        <member name="M:NLog.Config.IInstallable.Uninstall(NLog.Config.InstallationContext)">
            <summary>
            Performs uninstallation which requires administrative permissions.
            </summary>
            <param name="installationContext">The installation context.</param>
        </member>
        <member name="M:NLog.Config.IInstallable.IsInstalled(NLog.Config.InstallationContext)">
            <summary>
            Determines whether the item is installed.
            </summary>
            <param name="installationContext">The installation context.</param>
            <returns>
            Value indicating whether the item is installed or null if it is not possible to determine.
            </returns>
        </member>
        <member name="T:NLog.Config.ILoggingConfigurationElement">
            <summary>
            Interface for accessing configuration details
            </summary>
        </member>
        <member name="P:NLog.Config.ILoggingConfigurationElement.Name">
            <summary>
            Name of this configuration element
            </summary>
        </member>
        <member name="P:NLog.Config.ILoggingConfigurationElement.Values">
            <summary>
            Configuration Key/Value Pairs
            </summary>
        </member>
        <member name="P:NLog.Config.ILoggingConfigurationElement.Children">
            <summary>
            Child configuration elements
            </summary>
        </member>
        <member name="T:NLog.Config.ILoggingConfigurationLoader">
            <summary>
            Interface for loading NLog <see cref="T:NLog.Config.LoggingConfiguration"/>
            </summary>
        </member>
        <member name="M:NLog.Config.ILoggingConfigurationLoader.Load(NLog.LogFactory,System.String)">
            <summary>
            Finds and loads the NLog configuration
            </summary>
            <param name="logFactory">LogFactory that owns the NLog configuration</param>
            <param name="filename">Name of NLog.config file (optional)</param>
            <returns>NLog configuration (or null if none found)</returns>
        </member>
        <member name="M:NLog.Config.ILoggingConfigurationLoader.Activated(NLog.LogFactory,NLog.Config.LoggingConfiguration)">
            <summary>
            Notifies when LoggingConfiguration has been successfully applied
            </summary>
            <param name="logFactory">LogFactory that owns the NLog configuration</param>
            <param name="config">NLog Config</param>
        </member>
        <member name="M:NLog.Config.ILoggingConfigurationLoader.GetDefaultCandidateConfigFilePaths(System.String)">
            <summary>
            Get file paths (including filename) for the possible NLog config files.
            </summary>
            <param name="filename">Name of NLog.config file (optional)</param>
            <returns>The file paths to the possible config file</returns>
        </member>
        <member name="P:NLog.Config.ILoggingRuleLevelFilter.LogLevels">
            <summary>
            Level enabled flags for each LogLevel ordinal
            </summary>
        </member>
        <member name="M:NLog.Config.ILoggingRuleLevelFilter.GetSimpleFilterForUpdate">
            <summary>
            Converts the filter into a simple <see cref="T:NLog.Config.LoggingRuleLevelFilter"/>
            </summary>
        </member>
        <member name="T:NLog.Config.INamedItemFactory`2">
            <summary>
            Obsolete since dynamic type loading is not compatible with publish as trimmed application. Replaced by <see cref="T:NLog.Config.IFactory`1"/>.
            Represents a factory of named items (such as targets, layouts, layout renderers, etc.).
            </summary>
            <typeparam name="TInstanceType">Base type for each item instance.</typeparam>
            <typeparam name="TDefinitionType">Item definition type (typically <see cref="T:System.Type"/>).</typeparam>
        </member>
        <member name="M:NLog.Config.INamedItemFactory`2.RegisterDefinition(System.String,`1)">
            <summary>
            Registers new item definition.
            </summary>
            <param name="itemName">Name of the item.</param>
            <param name="itemDefinition">Item definition.</param>
        </member>
        <member name="M:NLog.Config.INamedItemFactory`2.TryGetDefinition(System.String,`1@)">
            <summary>
            Tries to get registered item definition.
            </summary>
            <param name="itemName">Name of the item.</param>
            <param name="result">Reference to a variable which will store the item definition.</param>
            <returns>Item definition.</returns>
        </member>
        <member name="M:NLog.Config.INamedItemFactory`2.CreateInstance(System.String)">
            <summary>
            Creates item instance.
            </summary>
            <param name="itemName">Name of the item.</param>
            <returns>Newly created item instance.</returns>
        </member>
        <member name="M:NLog.Config.INamedItemFactory`2.TryCreateInstance(System.String,`0@)">
            <summary>
            Tries to create an item instance.
            </summary>
            <param name="itemName">Name of the item.</param>
            <param name="result">The result.</param>
            <returns>True if instance was created successfully, false otherwise.</returns>
        </member>
        <member name="T:NLog.Config.InstallationContext">
            <summary>
            Provides context for install/uninstall operations.
            </summary>
        </member>
        <member name="F:NLog.Config.InstallationContext.LogLevel2ConsoleColor">
            <summary>
            Mapping between log levels and console output colors.
            </summary>
        </member>
        <member name="M:NLog.Config.InstallationContext.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Config.InstallationContext"/> class.
            </summary>
        </member>
        <member name="M:NLog.Config.InstallationContext.#ctor(System.IO.TextWriter)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Config.InstallationContext"/> class.
            </summary>
            <param name="logOutput">The log output.</param>
        </member>
        <member name="P:NLog.Config.InstallationContext.LogLevel">
            <summary>
            Gets or sets the installation log level.
            </summary>
        </member>
        <member name="P:NLog.Config.InstallationContext.IgnoreFailures">
            <summary>
            Gets or sets a value indicating whether to ignore failures during installation.
            </summary>
        </member>
        <member name="P:NLog.Config.InstallationContext.ThrowExceptions">
            <summary>
            Whether installation exceptions should be rethrown. If IgnoreFailures is set to true,
            this property has no effect (there are no exceptions to rethrow).
            </summary>
        </member>
        <member name="P:NLog.Config.InstallationContext.Parameters">
            <summary>
            Gets the installation parameters.
            </summary>
        </member>
        <member name="P:NLog.Config.InstallationContext.LogOutput">
            <summary>
            Gets or sets the log output.
            </summary>
        </member>
        <member name="M:NLog.Config.InstallationContext.Trace(System.String,System.Object[])">
            <summary>
            Logs the specified trace message.
            </summary>
            <param name="message">The message.</param>
            <param name="arguments">The arguments.</param>
        </member>
        <member name="M:NLog.Config.InstallationContext.Debug(System.String,System.Object[])">
            <summary>
            Logs the specified debug message.
            </summary>
            <param name="message">The message.</param>
            <param name="arguments">The arguments.</param>
        </member>
        <member name="M:NLog.Config.InstallationContext.Info(System.String,System.Object[])">
            <summary>
            Logs the specified informational message.
            </summary>
            <param name="message">The message.</param>
            <param name="arguments">The arguments.</param>
        </member>
        <member name="M:NLog.Config.InstallationContext.Warning(System.String,System.Object[])">
            <summary>
            Logs the specified warning message.
            </summary>
            <param name="message">The message.</param>
            <param name="arguments">The arguments.</param>
        </member>
        <member name="M:NLog.Config.InstallationContext.Error(System.String,System.Object[])">
            <summary>
            Logs the specified error message.
            </summary>
            <param name="message">The message.</param>
            <param name="arguments">The arguments.</param>
        </member>
        <member name="M:NLog.Config.InstallationContext.Dispose">
            <summary>
            Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
            </summary>
        </member>
        <member name="M:NLog.Config.InstallationContext.CreateLogEvent">
            <summary>
            Creates the log event which can be used to render layouts during install/uninstall.
            </summary>
            <returns>Log event info object.</returns>
        </member>
        <member name="T:NLog.Config.IPropertyTypeConverter">
            <summary>
            Convert object-value into specified type
            </summary>
        </member>
        <member name="M:NLog.Config.IPropertyTypeConverter.Convert(System.Object,System.Type,System.String,System.IFormatProvider)">
            <summary>
            Parses the input value and converts into the wanted type
            </summary>
            <param name="propertyValue">Input Value</param>
            <param name="propertyType">Wanted Type</param>
            <param name="format">Format to use when parsing</param>
            <param name="formatProvider">Culture to use when parsing</param>
            <returns>Output value with wanted type</returns>
        </member>
        <member name="T:NLog.Config.ISetupBuilder">
            <summary>
            Interface for fluent setup of LogFactory options
            </summary>
        </member>
        <member name="P:NLog.Config.ISetupBuilder.LogFactory">
            <summary>
            LogFactory under configuration
            </summary>
        </member>
        <member name="T:NLog.Config.ISetupConfigurationLoggingRuleBuilder">
            <summary>
            Interface for fluent setup of LoggingRules for LoggingConfiguration
            </summary>
        </member>
        <member name="P:NLog.Config.ISetupConfigurationLoggingRuleBuilder.LoggingRule">
            <summary>
            LoggingRule being built
            </summary>
        </member>
        <member name="T:NLog.Config.ISetupConfigurationTargetBuilder">
            <summary>
            Interface for fluent setup of target for LoggingRule
            </summary>
        </member>
        <member name="P:NLog.Config.ISetupConfigurationTargetBuilder.Configuration">
            <summary>
            LoggingConfiguration being built
            </summary>
        </member>
        <member name="P:NLog.Config.ISetupConfigurationTargetBuilder.LogFactory">
            <summary>
            LogFactory under configuration
            </summary>
        </member>
        <member name="P:NLog.Config.ISetupConfigurationTargetBuilder.Targets">
            <summary>
            Collection of targets that should be written to
            </summary>
        </member>
        <member name="T:NLog.Config.ISetupExtensionsBuilder">
            <summary>
            Interface for fluent setup of LogFactory options for extension loading
            </summary>
        </member>
        <member name="P:NLog.Config.ISetupExtensionsBuilder.LogFactory">
            <summary>
            LogFactory under configuration
            </summary>
        </member>
        <member name="T:NLog.Config.ISetupInternalLoggerBuilder">
            <summary>
            Interface for fluent setup of LogFactory options for enabling NLog <see cref="T:NLog.Common.InternalLogger"/>
            </summary>
        </member>
        <member name="P:NLog.Config.ISetupInternalLoggerBuilder.LogFactory">
            <summary>
            LogFactory under configuration
            </summary>
        </member>
        <member name="T:NLog.Config.ISetupLoadConfigurationBuilder">
            <summary>
            Interface for fluent setup of LoggingConfiguration for LogFactory
            </summary>
        </member>
        <member name="P:NLog.Config.ISetupLoadConfigurationBuilder.LogFactory">
            <summary>
            LogFactory under configuration
            </summary>
        </member>
        <member name="P:NLog.Config.ISetupLoadConfigurationBuilder.Configuration">
            <summary>
            LoggingConfiguration being built
            </summary>
        </member>
        <member name="T:NLog.Config.ISetupLogFactoryBuilder">
            <summary>
            Interface for fluent setup of LogFactory options
            </summary>
        </member>
        <member name="P:NLog.Config.ISetupLogFactoryBuilder.LogFactory">
            <summary>
            LogFactory under configuration
            </summary>
        </member>
        <member name="T:NLog.Config.ISetupSerializationBuilder">
            <summary>
            Interface for fluent setup of LogFactory options for logevent serialization
            </summary>
        </member>
        <member name="P:NLog.Config.ISetupSerializationBuilder.LogFactory">
            <summary>
            LogFactory under configuration
            </summary>
        </member>
        <member name="T:NLog.Config.IUsesStackTrace">
            <summary>
            Allows components to request stack trace information to be provided in the <see cref="T:NLog.LogEventInfo"/>.
            </summary>
        </member>
        <member name="P:NLog.Config.IUsesStackTrace.StackTraceUsage">
            <summary>
            Gets the level of stack trace information required by the implementing class.
            </summary>
        </member>
        <member name="T:NLog.Config.LoggerNameMatcher">
            <summary>
            Encapsulates <see cref="P:NLog.Config.LoggingRule.LoggerNamePattern"/> and the logic to match the actual logger name
            All subclasses defines immutable objects.
            Concrete subclasses defines various matching rules through <see cref="M:NLog.Config.LoggerNameMatcher.NameMatches(System.String)"/>
            </summary>
        </member>
        <member name="M:NLog.Config.LoggerNameMatcher.Create(System.String)">
            <summary>
            Creates a concrete <see cref="T:NLog.Config.LoggerNameMatcher"/> based on <paramref name="loggerNamePattern"/>.
            </summary>
            <remarks>
            Rules used to select the concrete implementation returned:
            <list type="number">
            <item>if <paramref name="loggerNamePattern"/> is null => returns <see cref="T:NLog.Config.LoggerNameMatcher.NoneLoggerNameMatcher"/> (never matches)</item>
            <item>if <paramref name="loggerNamePattern"/> doesn't contains any '*' nor '?' => returns <see cref="T:NLog.Config.LoggerNameMatcher.EqualsLoggerNameMatcher"/> (matches only on case sensitive equals)</item>
            <item>if <paramref name="loggerNamePattern"/> == '*' => returns <see cref="T:NLog.Config.LoggerNameMatcher.AllLoggerNameMatcher"/> (always matches)</item>
            <item>if <paramref name="loggerNamePattern"/> doesn't contain '?'
            <list type="number">
                <item>if <paramref name="loggerNamePattern"/> contains exactly 2 '*' one at the beginning and one at the end (i.e. "*foobar*) => returns <see cref="T:NLog.Config.LoggerNameMatcher.ContainsLoggerNameMatcher"/></item>
                <item>if <paramref name="loggerNamePattern"/> contains exactly 1 '*' at the beginning (i.e. "*foobar") => returns <see cref="T:NLog.Config.LoggerNameMatcher.EndsWithLoggerNameMatcher"/></item>
                <item>if <paramref name="loggerNamePattern"/> contains exactly 1 '*' at the end (i.e. "foobar*") => returns <see cref="T:NLog.Config.LoggerNameMatcher.StartsWithLoggerNameMatcher"/></item>
            </list>
            </item>
            <item>returns <see cref="T:NLog.Config.LoggerNameMatcher.MultiplePatternLoggerNameMatcher"/></item>
            </list>
            </remarks>
            <param name="loggerNamePattern">
            It may include one or more '*' or '?' wildcards at any position.
            <list type="bullet">
            <item>'*' means zero or more occurrences of any character</item>
            <item>'?' means exactly one occurrence of any character</item>
            </list>
            </param>
            <returns>A concrete <see cref="T:NLog.Config.LoggerNameMatcher"/></returns>
        </member>
        <member name="P:NLog.Config.LoggerNameMatcher.Pattern">
            <summary>
            Returns the argument passed to <see cref="M:NLog.Config.LoggerNameMatcher.Create(System.String)"/>
            </summary>
        </member>
        <member name="M:NLog.Config.LoggerNameMatcher.NameMatches(System.String)">
            <summary>
            Checks whether given name matches the logger name pattern.
            </summary>
            <param name="loggerName">String to be matched.</param>
            <returns>A value of <see langword="true"/> when the name matches, <see langword="false" /> otherwise.</returns>
        </member>
        <member name="T:NLog.Config.LoggerNameMatcher.NoneLoggerNameMatcher">
            <summary>
            Defines a <see cref="T:NLog.Config.LoggerNameMatcher"/> that never matches.
            Used when pattern is null
            </summary>
        </member>
        <member name="T:NLog.Config.LoggerNameMatcher.AllLoggerNameMatcher">
            <summary>
            Defines a <see cref="T:NLog.Config.LoggerNameMatcher"/> that always matches.
            Used when pattern is '*'
            </summary>
        </member>
        <member name="T:NLog.Config.LoggerNameMatcher.EqualsLoggerNameMatcher">
            <summary>
            Defines a <see cref="T:NLog.Config.LoggerNameMatcher"/> that matches with a case-sensitive Equals
            Used when pattern is a string without wildcards '?' '*'
            </summary>
        </member>
        <member name="T:NLog.Config.LoggerNameMatcher.StartsWithLoggerNameMatcher">
            <summary>
            Defines a <see cref="T:NLog.Config.LoggerNameMatcher"/> that matches with a case-sensitive StartsWith
            Used when pattern is a string like "*foobar"
            </summary>
        </member>
        <member name="T:NLog.Config.LoggerNameMatcher.EndsWithLoggerNameMatcher">
            <summary>
            Defines a <see cref="T:NLog.Config.LoggerNameMatcher"/> that matches with a case-sensitive EndsWith
            Used when pattern is a string like "foobar*"
            </summary>
        </member>
        <member name="T:NLog.Config.LoggerNameMatcher.ContainsLoggerNameMatcher">
            <summary>
            Defines a <see cref="T:NLog.Config.LoggerNameMatcher"/> that matches with a case-sensitive Contains
            Used when pattern is a string like "*foobar*"
            </summary>
        </member>
        <member name="T:NLog.Config.LoggerNameMatcher.MultiplePatternLoggerNameMatcher">
            <summary>
            Defines a <see cref="T:NLog.Config.LoggerNameMatcher"/> that matches with a complex wildcards combinations:
            <list type="bullet">
            <item>'*' means zero or more occurrences of any character</item>
            <item>'?' means exactly one occurrence of any character</item>
            </list>
            used when pattern is a string containing any number of '?' or '*' in any position
            i.e. "*Server[*].Connection[?]"
            </summary>
        </member>
        <member name="T:NLog.Config.LoggingConfiguration">
             <summary>
             Keeps logging configuration and provides simple API to modify it.
             </summary>
            <remarks>This class is thread-safe.<c>.ToList()</c> is used for that purpose.</remarks>
        </member>
        <member name="P:NLog.Config.LoggingConfiguration.LogFactory">
            <summary>
            Gets the factory that will be configured
            </summary>
        </member>
        <member name="M:NLog.Config.LoggingConfiguration.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Config.LoggingConfiguration" /> class.
            </summary>
        </member>
        <member name="M:NLog.Config.LoggingConfiguration.#ctor(NLog.LogFactory)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Config.LoggingConfiguration" /> class.
            </summary>
        </member>
        <member name="P:NLog.Config.LoggingConfiguration.Variables">
            <summary>
            Gets the variables defined in the configuration or assigned from API
            </summary>
            <remarks>Name is case insensitive.</remarks>
        </member>
        <member name="P:NLog.Config.LoggingConfiguration.ConfiguredNamedTargets">
            <summary>
            Gets a collection of named targets specified in the configuration.
            </summary>
            <returns>
            A list of named targets.
            </returns>
            <remarks>
            Unnamed targets (such as those wrapped by other targets) are not returned.
            </remarks>
        </member>
        <member name="P:NLog.Config.LoggingConfiguration.FileNamesToWatch">
            <summary>
            Gets the collection of file names which should be watched for changes by NLog.
            </summary>
        </member>
        <member name="P:NLog.Config.LoggingConfiguration.LoggingRules">
            <summary>
            Gets the collection of logging rules.
            </summary>
        </member>
        <member name="P:NLog.Config.LoggingConfiguration.DefaultCultureInfo">
            <summary>
            Gets or sets the default culture info to use as <see cref="P:NLog.LogEventInfo.FormatProvider"/>.
            </summary>
            <value>
            Specific culture info or null to use <see cref="P:System.Globalization.CultureInfo.CurrentCulture"/>
            </value>
        </member>
        <member name="P:NLog.Config.LoggingConfiguration.AllTargets">
            <summary>
            Gets all targets.
            </summary>
        </member>
        <member name="M:NLog.Config.LoggingConfiguration.InsertParsedConfigVariable(System.String,NLog.Layouts.Layout)">
            <summary>
            Inserts NLog Config Variable without overriding NLog Config Variable assigned from API
            </summary>
        </member>
        <member name="M:NLog.Config.LoggingConfiguration.TryLookupDynamicVariable(System.String,NLog.Layouts.Layout@)">
            <summary>
            Lookup NLog Config Variable Layout
            </summary>
        </member>
        <member name="M:NLog.Config.LoggingConfiguration.AddTarget(NLog.Targets.Target)">
            <summary>
            Registers the specified target object. The name of the target is read from <see cref="P:NLog.Targets.Target.Name"/>.
            </summary>
            <param name="target">
            The target object with a non <see langword="null"/> <see cref="P:NLog.Targets.Target.Name"/>
            </param>
            <exception cref="T:System.ArgumentNullException">when <paramref name="target"/> is <see langword="null"/></exception>
        </member>
        <member name="M:NLog.Config.LoggingConfiguration.AddTarget(System.String,NLog.Targets.Target)">
            <summary>
            Registers the specified target object under a given name.
            </summary>
            <param name="name">Name of the target.</param>
            <param name="target">The target object.</param>
            <exception cref="T:System.ArgumentException">when <paramref name="name"/> is <see langword="null"/></exception>
            <exception cref="T:System.ArgumentNullException">when <paramref name="target"/> is <see langword="null"/></exception>
        </member>
        <member name="M:NLog.Config.LoggingConfiguration.FindTargetByName(System.String)">
            <summary>
            Finds the target with the specified name.
            </summary>
            <param name="name">
            The name of the target to be found.
            </param>
            <returns>
            Found target or <see langword="null"/> when the target is not found.
            </returns>
        </member>
        <member name="M:NLog.Config.LoggingConfiguration.FindTargetByName``1(System.String)">
            <summary>
            Finds the target with the specified name and specified type.
            </summary>
            <param name="name">
            The name of the target to be found.
            </param>
            <typeparam name="TTarget">Type of the target</typeparam>
            <returns>
            Found target or <see langword="null"/> when the target is not found of not of type <typeparamref name="TTarget"/>
            </returns>
        </member>
        <member name="M:NLog.Config.LoggingConfiguration.AddRule(NLog.LogLevel,NLog.LogLevel,System.String,System.String)">
            <summary>
            Add a rule with min- and maxLevel.
            </summary>
            <param name="minLevel">Minimum log level needed to trigger this rule.</param>
            <param name="maxLevel">Maximum log level needed to trigger this rule.</param>
            <param name="targetName">Name of the target to be written when the rule matches.</param>
            <param name="loggerNamePattern">Logger name pattern. It may include the '*' wildcard at the beginning, at the end or at both ends.</param>
        </member>
        <member name="M:NLog.Config.LoggingConfiguration.AddRule(NLog.LogLevel,NLog.LogLevel,NLog.Targets.Target,System.String)">
            <summary>
            Add a rule with min- and maxLevel.
            </summary>
            <param name="minLevel">Minimum log level needed to trigger this rule.</param>
            <param name="maxLevel">Maximum log level needed to trigger this rule.</param>
            <param name="target">Target to be written to when the rule matches.</param>
            <param name="loggerNamePattern">Logger name pattern. It may include the '*' wildcard at the beginning, at the end or at both ends.</param>
        </member>
        <member name="M:NLog.Config.LoggingConfiguration.AddRule(NLog.LogLevel,NLog.LogLevel,NLog.Targets.Target,System.String,System.Boolean)">
            <summary>
            Add a rule with min- and maxLevel.
            </summary>
            <param name="minLevel">Minimum log level needed to trigger this rule.</param>
            <param name="maxLevel">Maximum log level needed to trigger this rule.</param>
            <param name="target">Target to be written to when the rule matches.</param>
            <param name="loggerNamePattern">Logger name pattern. It may include the '*' wildcard at the beginning, at the end or at both ends.</param>
            <param name="final">Gets or sets a value indicating whether to quit processing any further rule when this one matches.</param>
        </member>
        <member name="M:NLog.Config.LoggingConfiguration.AddRule(NLog.Config.LoggingRule)">
            <summary>
            Add a rule object.
            </summary>
            <param name="rule">rule object to add</param>
        </member>
        <member name="M:NLog.Config.LoggingConfiguration.AddRuleForOneLevel(NLog.LogLevel,System.String,System.String)">
            <summary>
            Add a rule for one loglevel.
            </summary>
            <param name="level">log level needed to trigger this rule. </param>
            <param name="targetName">Name of the target to be written when the rule matches.</param>
            <param name="loggerNamePattern">Logger name pattern. It may include the '*' wildcard at the beginning, at the end or at both ends.</param>
        </member>
        <member name="M:NLog.Config.LoggingConfiguration.AddRuleForOneLevel(NLog.LogLevel,NLog.Targets.Target,System.String)">
            <summary>
            Add a rule for one loglevel.
            </summary>
            <param name="level">log level needed to trigger this rule. </param>
            <param name="target">Target to be written to when the rule matches.</param>
            <param name="loggerNamePattern">Logger name pattern. It may include the '*' wildcard at the beginning, at the end or at both ends.</param>
        </member>
        <member name="M:NLog.Config.LoggingConfiguration.AddRuleForOneLevel(NLog.LogLevel,NLog.Targets.Target,System.String,System.Boolean)">
            <summary>
            Add a rule for one loglevel.
            </summary>
            <param name="level">log level needed to trigger this rule. </param>
            <param name="target">Target to be written to when the rule matches.</param>
            <param name="loggerNamePattern">Logger name pattern. It may include the '*' wildcard at the beginning, at the end or at both ends.</param>
            <param name="final">Gets or sets a value indicating whether to quit processing any further rule when this one matches.</param>
        </member>
        <member name="M:NLog.Config.LoggingConfiguration.AddRuleForAllLevels(System.String,System.String)">
            <summary>
            Add a rule for all loglevels.
            </summary>
            <param name="targetName">Name of the target to be written when the rule matches.</param>
            <param name="loggerNamePattern">Logger name pattern. It may include the '*' wildcard at the beginning, at the end or at both ends.</param>
        </member>
        <member name="M:NLog.Config.LoggingConfiguration.AddRuleForAllLevels(NLog.Targets.Target,System.String)">
            <summary>
            Add a rule for all loglevels.
            </summary>
            <param name="target">Target to be written to when the rule matches.</param>
            <param name="loggerNamePattern">Logger name pattern. It may include the '*' wildcard at the beginning, at the end or at both ends.</param>
        </member>
        <member name="M:NLog.Config.LoggingConfiguration.AddRuleForAllLevels(NLog.Targets.Target,System.String,System.Boolean)">
            <summary>
            Add a rule for all loglevels.
            </summary>
            <param name="target">Target to be written to when the rule matches.</param>
            <param name="loggerNamePattern">Logger name pattern. It may include the '*' wildcard at the beginning, at the end or at both ends.</param>
            <param name="final">Gets or sets a value indicating whether to quit processing any further rule when this one matches.</param>
        </member>
        <member name="M:NLog.Config.LoggingConfiguration.FindRuleByName(System.String)">
            <summary>
            Lookup the logging rule with matching <see cref="P:NLog.Config.LoggingRule.RuleName"/>
            </summary>
            <param name="ruleName">The name of the logging rule to be found.</param>
            <returns>Found logging rule or <see langword="null"/> when not found.</returns>
        </member>
        <member name="M:NLog.Config.LoggingConfiguration.RemoveRuleByName(System.String)">
            <summary>
            Removes the specified named logging rule with matching <see cref="P:NLog.Config.LoggingRule.RuleName"/>
            </summary>
            <param name="ruleName">The name of the logging rule to be removed.</param>
            <returns>Found one or more logging rule to remove, or <see langword="false"/> when not found.</returns>
        </member>
        <member name="M:NLog.Config.LoggingConfiguration.Reload">
            <summary>
            Called by LogManager when one of the log configuration files changes.
            </summary>
            <returns>
            A new instance of <see cref="T:NLog.Config.LoggingConfiguration"/> that represents the updated configuration.
            </returns>
            <remarks>Must assign the returned object to LogManager.Configuration to activate it</remarks>
        </member>
        <member name="M:NLog.Config.LoggingConfiguration.PrepareForReload(NLog.Config.LoggingConfiguration)">
            <summary>
            Allow this new configuration to capture state from the old configuration
            </summary>
            <param name="oldConfig">Old config that is about to be replaced</param>
            <remarks>Checks KeepVariablesOnReload and copies all NLog Config Variables assigned from API into the new config</remarks>
        </member>
        <member name="M:NLog.Config.LoggingConfiguration.OnConfigurationAssigned(NLog.LogFactory)">
            <summary>
            Notify the configuration when <see cref="P:NLog.LogFactory.Configuration"/> has been assigned / unassigned.
            </summary>
            <param name="logFactory">LogFactory that configuration has been assigned to.</param>
        </member>
        <member name="M:NLog.Config.LoggingConfiguration.RemoveTarget(System.String)">
            <summary>
            Removes the specified named target.
            </summary>
            <param name="name">Name of the target.</param>
        </member>
        <member name="M:NLog.Config.LoggingConfiguration.Install(NLog.Config.InstallationContext)">
            <summary>
            Installs target-specific objects on current system.
            </summary>
            <param name="installationContext">The installation context.</param>
            <remarks>
            Installation typically runs with administrative permissions.
            </remarks>
        </member>
        <member name="M:NLog.Config.LoggingConfiguration.Uninstall(NLog.Config.InstallationContext)">
            <summary>
            Uninstalls target-specific objects from current system.
            </summary>
            <param name="installationContext">The installation context.</param>
            <remarks>
            Uninstallation typically runs with administrative permissions.
            </remarks>
        </member>
        <member name="M:NLog.Config.LoggingConfiguration.Close">
            <summary>
            Closes all targets and releases any unmanaged resources.
            </summary>
        </member>
        <member name="M:NLog.Config.LoggingConfiguration.Dump">
            <summary>
            Log to the internal (NLog) logger the information about the <see cref="T:NLog.Targets.Target"/> and <see
            cref="T:NLog.Config.LoggingRule"/> associated with this <see cref="T:NLog.Config.LoggingConfiguration"/> instance.
            </summary>
            <remarks>
            The information are only recorded in the internal logger if Debug level is enabled, otherwise nothing is
            recorded.
            </remarks>
        </member>
        <member name="M:NLog.Config.LoggingConfiguration.ValidateConfig">
            <summary>
            Validates the configuration.
            </summary>
        </member>
        <member name="M:NLog.Config.LoggingConfiguration.ExpandSimpleVariables(System.String)">
            <summary>
            Replace a simple variable with a value. The original value is removed and thus we cannot redo this in a later stage.
            </summary>
            <param name="input"></param>
            <returns></returns>
        </member>
        <member name="M:NLog.Config.LoggingConfiguration.CheckUnusedTargets">
            <summary>
            Checks whether unused targets exist. If found any, just write an internal log at Warn level.
            <remarks>If initializing not started or failed, then checking process will be canceled</remarks>
            </summary>
        </member>
        <member name="M:NLog.Config.LoggingConfiguration.FlushAllTargetsAsync(NLog.Config.LoggingConfiguration,NLog.Common.AsyncContinuation,System.Nullable{System.TimeSpan})">
            <summary>
            Flushes any pending log messages on all appenders.
            </summary>
            <param name="loggingConfiguration">Config containing Targets to Flush</param>
            <param name="asyncContinuation">Flush completed notification (success / timeout)</param>
            <param name="asyncTimeout">Optional timeout that guarantees that completed notification is called.</param>
            <returns></returns>
        </member>
        <member name="M:NLog.Config.LoggingConfiguration.BuildLoggerConfiguration(System.String,NLog.LogLevel,System.Collections.Generic.List{NLog.Config.LoggingRule})">
            <summary>
            Change this method with NLog v6 to disconnect LogFactory from Targets/Layouts
            - Remove LoggingRule-List-parameter
            - Return ITargetWithFilterChain[]
            </summary>
        </member>
        <member name="M:NLog.Config.LoggingConfiguration.ToString">
            <inheritdoc/>
        </member>
        <member name="T:NLog.Config.LoggingConfigurationChangedEventArgs">
            <summary>
            Arguments for <see cref="E:NLog.LogFactory.ConfigurationChanged"/> events.
            </summary>
        </member>
        <member name="M:NLog.Config.LoggingConfigurationChangedEventArgs.#ctor(NLog.Config.LoggingConfiguration,NLog.Config.LoggingConfiguration)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Config.LoggingConfigurationChangedEventArgs" /> class.
            </summary>
            <param name="activatedConfiguration">The new configuration.</param>
            <param name="deactivatedConfiguration">The old configuration.</param>
        </member>
        <member name="P:NLog.Config.LoggingConfigurationChangedEventArgs.DeactivatedConfiguration">
            <summary>
            Gets the old configuration.
            </summary>
            <value>The old configuration.</value>
        </member>
        <member name="P:NLog.Config.LoggingConfigurationChangedEventArgs.ActivatedConfiguration">
            <summary>
            Gets the new configuration.
            </summary>
            <remarks>
            New value can be <c>null</c> when unloading configuration during shutdown.
            </remarks>
            <value>The new configuration.</value>
        </member>
        <member name="M:NLog.Config.LoggingConfigurationElementExtensions.GetOptionalBooleanValue(NLog.Config.ILoggingConfigurationElement,System.String,System.Boolean)">
            <summary>
            Gets the optional boolean attribute value.
            </summary>
            <param name="element"></param>
            <param name="attributeName">Name of the attribute.</param>
            <param name="defaultValue">Default value to return if the attribute is not found or if there is a parse error</param>
            <returns>Boolean attribute value or default.</returns>
        </member>
        <member name="M:NLog.Config.LoggingConfigurationElementExtensions.StripOptionalNamespacePrefix(System.String)">
            <summary>
            Remove the namespace (before :)
            </summary>
            <example>
            x:a, will be a
            </example>
            <param name="attributeValue"></param>
            <returns></returns>
        </member>
        <member name="T:NLog.Config.LoggingConfigurationFileLoader">
            <summary>
            Enables loading of NLog configuration from a file
            </summary>
        </member>
        <member name="M:NLog.Config.LoggingConfigurationFileLoader.GetDefaultCandidateConfigFilePaths(System.String)">
            <summary>
            Get default file paths (including filename) for possible NLog config files.
            </summary>
        </member>
        <member name="M:NLog.Config.LoggingConfigurationFileLoader.GetAppSpecificNLogLocations(System.String,System.String)">
            <summary>
            Get default file paths (including filename) for possible NLog config files.
            </summary>
        </member>
        <member name="T:NLog.Config.LoggingConfigurationParser">
            <summary>
            Loads NLog configuration from <see cref="T:NLog.Config.ILoggingConfigurationElement"/>
            </summary>
        </member>
        <member name="M:NLog.Config.LoggingConfigurationParser.#ctor(NLog.LogFactory)">
            <summary>
            Constructor
            </summary>
            <param name="logFactory"></param>
        </member>
        <member name="M:NLog.Config.LoggingConfigurationParser.LoadConfig(NLog.Config.ILoggingConfigurationElement,System.String)">
            <summary>
            Loads NLog configuration from provided config section
            </summary>
            <param name="nlogConfig"></param>
            <param name="basePath">Directory where the NLog-config-file was loaded from</param>
        </member>
        <member name="M:NLog.Config.LoggingConfigurationParser.CreateUniqueSortedListFromConfig(NLog.Config.ILoggingConfigurationElement)">
            <summary>
            Builds list with unique keys, using last value of duplicates. High priority keys placed first.
            </summary>
            <param name="nlogConfig"></param>
            <returns></returns>
        </member>
        <member name="M:NLog.Config.LoggingConfigurationParser.ParseLogLevelSafe(System.String,System.String,NLog.LogLevel)">
            <summary>
            Parse loglevel, but don't throw if exception throwing is disabled
            </summary>
            <param name="propertyName">Name of attribute for logging.</param>
            <param name="propertyValue">Value of parse.</param>
            <param name="fallbackValue">Used if there is an exception</param>
            <returns></returns>
        </member>
        <member name="M:NLog.Config.LoggingConfigurationParser.ParseNLogSection(NLog.Config.ILoggingConfigurationElement)">
            <summary>
            Parses a single config section within the NLog-config
            </summary>
            <param name="configSection"></param>
            <returns>Section was recognized</returns>
        </member>
        <member name="M:NLog.Config.LoggingConfigurationParser.ParseRulesElement(NLog.Config.LoggingConfigurationParser.ValidatedConfigurationElement,System.Collections.Generic.IList{NLog.Config.LoggingRule})">
            <summary>
            Parse {Rules} xml element
            </summary>
            <param name="rulesElement"></param>
            <param name="rulesCollection">Rules are added to this parameter.</param>
        </member>
        <member name="M:NLog.Config.LoggingConfigurationParser.ParseRuleElement(NLog.Config.LoggingConfigurationParser.ValidatedConfigurationElement)">
            <summary>
            Parse {Logger} xml element
            </summary>
            <param name="loggerElement"></param>
        </member>
        <member name="M:NLog.Config.LoggingConfigurationParser.ParseBooleanValue(System.String,System.String,System.Boolean)">
            <summary>
            Parse boolean
            </summary>
            <param name="propertyName">Name of the property for logging.</param>
            <param name="value">value to parse</param>
            <param name="defaultValue">Default value to return if the parse failed</param>
            <returns>Boolean attribute value or default.</returns>
        </member>
        <member name="T:NLog.Config.LoggingConfigurationParser.ValidatedConfigurationElement">
            <summary>
            Config element that's validated and having extra context
            </summary>
        </member>
        <member name="P:NLog.Config.LoggingConfigurationParser.ValidatedConfigurationElement.NLog#Config#ILoggingConfigurationElement#Children">
            <remarks>
            Explicit cast because NET35 doesn't support covariance.
            </remarks>
        </member>
        <member name="T:NLog.Config.LoggingConfigurationReloadedEventArgs">
            <summary>
            Obsolete and replaced by <see cref="T:NLog.Config.LoggingConfigurationChangedEventArgs"/> and <see cref="E:NLog.LogFactory.ConfigurationChanged"/> with NLog v5.2.
            </summary>
        </member>
        <member name="M:NLog.Config.LoggingConfigurationReloadedEventArgs.#ctor(System.Boolean)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Config.LoggingConfigurationReloadedEventArgs" /> class.
            </summary>
            <param name="succeeded">Whether configuration reload has succeeded.</param>
        </member>
        <member name="M:NLog.Config.LoggingConfigurationReloadedEventArgs.#ctor(System.Boolean,System.Exception)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Config.LoggingConfigurationReloadedEventArgs" /> class.
            </summary>
            <param name="succeeded">Whether configuration reload has succeeded.</param>
            <param name="exception">The exception during configuration reload.</param>
        </member>
        <member name="P:NLog.Config.LoggingConfigurationReloadedEventArgs.Succeeded">
            <summary>
            Gets a value indicating whether configuration reload has succeeded.
            </summary>
            <value>A value of <c>true</c> if succeeded; otherwise, <c>false</c>.</value>
        </member>
        <member name="P:NLog.Config.LoggingConfigurationReloadedEventArgs.Exception">
            <summary>
            Gets the exception which occurred during configuration reload.
            </summary>
            <value>The exception.</value>
        </member>
        <member name="T:NLog.Config.LoggingConfigurationWatchableFileLoader">
            <summary>
            Enables FileWatcher for the currently loaded NLog Configuration File,
            and supports automatic reload on file modification.
            </summary>
        </member>
        <member name="T:NLog.Config.LoggingRule">
            <summary>
            Represents a logging rule. An equivalent of &lt;logger /&gt; configuration element.
            </summary>
        </member>
        <member name="M:NLog.Config.LoggingRule.#ctor">
            <summary>
            Create an empty <see cref="T:NLog.Config.LoggingRule" />.
            </summary>
        </member>
        <member name="M:NLog.Config.LoggingRule.#ctor(System.String)">
            <summary>
            Create an empty <see cref="T:NLog.Config.LoggingRule" />.
            </summary>
        </member>
        <member name="M:NLog.Config.LoggingRule.#ctor(System.String,NLog.LogLevel,NLog.LogLevel,NLog.Targets.Target)">
            <summary>
            Create a new <see cref="T:NLog.Config.LoggingRule" /> with a <paramref name="minLevel"/> and  <paramref name="maxLevel"/> which writes to <paramref name="target"/>.
            </summary>
            <param name="loggerNamePattern">Logger name pattern used for <see cref="P:NLog.Config.LoggingRule.LoggerNamePattern"/>. It may include one or more '*' or '?' wildcards at any position.</param>
            <param name="minLevel">Minimum log level needed to trigger this rule.</param>
            <param name="maxLevel">Maximum log level needed to trigger this rule.</param>
            <param name="target">Target to be written to when the rule matches.</param>
        </member>
        <member name="M:NLog.Config.LoggingRule.#ctor(System.String,NLog.LogLevel,NLog.Targets.Target)">
            <summary>
            Create a new <see cref="T:NLog.Config.LoggingRule" /> with a <paramref name="minLevel"/> which writes to <paramref name="target"/>.
            </summary>
            <param name="loggerNamePattern">Logger name pattern used for <see cref="P:NLog.Config.LoggingRule.LoggerNamePattern"/>. It may include one or more '*' or '?' wildcards at any position.</param>
            <param name="minLevel">Minimum log level needed to trigger this rule.</param>
            <param name="target">Target to be written to when the rule matches.</param>
        </member>
        <member name="M:NLog.Config.LoggingRule.#ctor(System.String,NLog.Targets.Target)">
            <summary>
            Create a (disabled) <see cref="T:NLog.Config.LoggingRule" />. You should call <see cref="M:NLog.Config.LoggingRule.EnableLoggingForLevel(NLog.LogLevel)"/> or <see cref="M:NLog.Config.LoggingRule.EnableLoggingForLevels(NLog.LogLevel,NLog.LogLevel)"/> to enable logging.
            </summary>
            <param name="loggerNamePattern">Logger name pattern used for <see cref="P:NLog.Config.LoggingRule.LoggerNamePattern"/>. It may include one or more '*' or '?' wildcards at any position.</param>
            <param name="target">Target to be written to when the rule matches.</param>
        </member>
        <member name="P:NLog.Config.LoggingRule.RuleName">
            <summary>
            Rule identifier to allow rule lookup
            </summary>
        </member>
        <member name="P:NLog.Config.LoggingRule.Targets">
            <summary>
            Gets a collection of targets that should be written to when this rule matches.
            </summary>
        </member>
        <member name="P:NLog.Config.LoggingRule.ChildRules">
             <summary>
             Obsolete since too exotic feature with NLog v5.3.
            
             Gets a collection of child rules to be evaluated when this rule matches.
             </summary>
        </member>
        <member name="P:NLog.Config.LoggingRule.Filters">
            <summary>
            Gets a collection of filters to be checked before writing to targets.
            </summary>
        </member>
        <member name="P:NLog.Config.LoggingRule.Final">
            <summary>
            Gets or sets a value indicating whether to quit processing any following rules when this one matches.
            </summary>
        </member>
        <member name="P:NLog.Config.LoggingRule.FinalMinLevel">
            <summary>
            Gets or sets the <see cref="T:NLog.LogLevel"/> whether to quit processing any following rules when lower severity and this one matches.
            </summary>
            <remarks>
            Loggers matching will be restricted to specified minimum level for following rules.
            </remarks>
        </member>
        <member name="P:NLog.Config.LoggingRule.LoggerNamePattern">
            <summary>
            Gets or sets logger name pattern.
            </summary>
            <remarks>
            Logger name pattern used by <see cref="M:NLog.Config.LoggingRule.NameMatches(System.String)"/> to check if a logger name matches this rule.
            It may include one or more '*' or '?' wildcards at any position.
            <list type="bullet">
            <item>'*' means zero or more occurrences of any character</item>
            <item>'?' means exactly one occurrence of any character</item>
            </list>
            </remarks>
        </member>
        <member name="P:NLog.Config.LoggingRule.Levels">
            <summary>
            Gets the collection of log levels enabled by this rule.
            </summary>
        </member>
        <member name="P:NLog.Config.LoggingRule.DefaultFilterResult">
             <summary>
             Obsolete and replaced by <see cref="P:NLog.Config.LoggingRule.FilterDefaultAction"/> with NLog v5.
            
             Default action when filters not matching
             </summary>
             <remarks>
             NLog v4.6 introduced the setting with default value <see cref="F:NLog.Filters.FilterResult.Neutral"/>.
             NLog v5 marked it as obsolete and change default value to <see cref="F:NLog.Filters.FilterResult.Ignore"/>
             </remarks>
        </member>
        <member name="P:NLog.Config.LoggingRule.FilterDefaultAction">
            <summary>
            Default action if none of the filters match
            </summary>
            <remarks>
            NLog v5 changed default value to <see cref="F:NLog.Filters.FilterResult.Ignore"/>
            </remarks>
        </member>
        <member name="M:NLog.Config.LoggingRule.EnableLoggingForLevel(NLog.LogLevel)">
            <summary>
            Enables logging for a particular level.
            </summary>
            <param name="level">Level to be enabled.</param>
        </member>
        <member name="M:NLog.Config.LoggingRule.EnableLoggingForLevels(NLog.LogLevel,NLog.LogLevel)">
            <summary>
            Enables logging for a particular levels between (included) <paramref name="minLevel"/> and <paramref name="maxLevel"/>.
            </summary>
            <param name="minLevel">Minimum log level needed to trigger this rule.</param>
            <param name="maxLevel">Maximum log level needed to trigger this rule.</param>
        </member>
        <member name="M:NLog.Config.LoggingRule.DisableLoggingForLevel(NLog.LogLevel)">
            <summary>
            Disables logging for a particular level.
            </summary>
            <param name="level">Level to be disabled.</param>
        </member>
        <member name="M:NLog.Config.LoggingRule.DisableLoggingForLevels(NLog.LogLevel,NLog.LogLevel)">
            <summary>
            Disables logging for particular levels between (included) <paramref name="minLevel"/> and <paramref name="maxLevel"/>.
            </summary>
            <param name="minLevel">Minimum log level to be disables.</param>
            <param name="maxLevel">Maximum log level to be disabled.</param>
        </member>
        <member name="M:NLog.Config.LoggingRule.SetLoggingLevels(NLog.LogLevel,NLog.LogLevel)">
            <summary>
            Enables logging the levels between (included) <paramref name="minLevel"/> and <paramref name="maxLevel"/>. All the other levels will be disabled.
            </summary>
            <param name="minLevel">Minimum log level needed to trigger this rule.</param>
            <param name="maxLevel">Maximum log level needed to trigger this rule.</param>
        </member>
        <member name="M:NLog.Config.LoggingRule.ToString">
            <summary>
            Returns a string representation of <see cref="T:NLog.Config.LoggingRule"/>. Used for debugging.
            </summary>
        </member>
        <member name="M:NLog.Config.LoggingRule.IsLoggingEnabledForLevel(NLog.LogLevel)">
            <summary>
            Checks whether the particular log level is enabled for this rule.
            </summary>
            <param name="level">Level to be checked.</param>
            <returns>A value of <see langword="true"/> when the log level is enabled, <see langword="false" /> otherwise.</returns>
        </member>
        <member name="M:NLog.Config.LoggingRule.NameMatches(System.String)">
            <summary>
            Checks whether given name matches the <see cref="P:NLog.Config.LoggingRule.LoggerNamePattern"/>.
            </summary>
            <param name="loggerName">String to be matched.</param>
            <returns>A value of <see langword="true"/> when the name matches, <see langword="false" /> otherwise.</returns>
        </member>
        <member name="T:NLog.Config.LoggingRuleLevelFilter">
            <summary>
            Default filtering with static level config
            </summary>
        </member>
        <member name="T:NLog.Config.MethodFactory">
            <summary>
            Factory for locating methods.
            </summary>
        </member>
        <member name="M:NLog.Config.MethodFactory.#ctor(NLog.Config.MethodFactory)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Config.MethodFactory"/> class.
            </summary>
        </member>
        <member name="M:NLog.Config.MethodFactory.ScanTypes(System.Type[],System.String,System.String)">
            <summary>
            Scans the assembly for classes marked with expected class <see cref="T:System.Attribute"/>
            and methods marked with expected <see cref="T:NLog.Config.NameBaseAttribute"/> and adds them
            to the factory.
            </summary>
            <param name="types">The types to scan.</param>
            <param name="assemblyName">The assembly name for the type.</param>
            <param name="itemNamePrefix">The item name prefix.</param>
        </member>
        <member name="M:NLog.Config.MethodFactory.NLog#Config#IFactory#RegisterType(System.Type,System.String)">
            <summary>
            Registers the type.
            </summary>
            <param name="type">The type to register.</param>
            <param name="itemNamePrefix">The item name prefix.</param>
        </member>
        <member name="M:NLog.Config.MethodFactory.RegisterType(System.Type,System.String)">
            <summary>
            Registers the type.
            </summary>
            <param name="type">The type to register.</param>
            <param name="itemNamePrefix">The item name prefix.</param>
        </member>
        <member name="M:NLog.Config.MethodFactory.ExtractClassMethods``2(System.Type)">
            <summary>
            Scans a type for relevant methods with their symbolic names
            </summary>
            <typeparam name="TClassAttributeType">Include types that are marked with this attribute</typeparam>
            <typeparam name="TMethodAttributeType">Include methods that are marked with this attribute</typeparam>
            <param name="type">Class Type to scan</param>
            <returns>Collection of methods with their symbolic names</returns>
        </member>
        <member name="M:NLog.Config.MethodFactory.Clear">
            <summary>
            Clears contents of the factory.
            </summary>
        </member>
        <member name="M:NLog.Config.MethodFactory.NLog#Config#INamedItemFactory{System#Reflection#MethodInfo,System#Reflection#MethodInfo}#RegisterDefinition(System.String,System.Reflection.MethodInfo)">
            <summary>
            Registers the definition of a single method.
            </summary>
            <param name="itemName">The method name.</param>
            <param name="itemDefinition">The method info.</param>
        </member>
        <member name="M:NLog.Config.MethodFactory.NLog#Config#INamedItemFactory{System#Reflection#MethodInfo,System#Reflection#MethodInfo}#TryCreateInstance(System.String,System.Reflection.MethodInfo@)">
            <summary>
            Tries to retrieve method by name.
            </summary>
            <param name="itemName">The method name.</param>
            <param name="result">The result.</param>
            <returns>A value of <c>true</c> if the method was found, <c>false</c> otherwise.</returns>
        </member>
        <member name="M:NLog.Config.MethodFactory.NLog#Config#INamedItemFactory{System#Reflection#MethodInfo,System#Reflection#MethodInfo}#CreateInstance(System.String)">
            <summary>
            Retrieves method by name.
            </summary>
            <param name="itemName">Method name.</param>
            <returns>MethodInfo object.</returns>
        </member>
        <member name="M:NLog.Config.MethodFactory.TryGetDefinition(System.String,System.Reflection.MethodInfo@)">
            <summary>
            Tries to get method definition.
            </summary>
            <param name="itemName">The method name.</param>
            <param name="result">The result.</param>
            <returns>A value of <c>true</c> if the method was found, <c>false</c> otherwise.</returns>
        </member>
        <member name="T:NLog.Config.MutableUnsafeAttribute">
             <summary>
             Obsolete and replaced by <see cref="T:NLog.Config.ThreadAgnosticImmutableAttribute"/> with NLog v5.3.
            
             Marks the layout or layout renderer depends on mutable objects from the LogEvent
            
             This can be <see cref="P:NLog.LogEventInfo.Properties"/> or <see cref="P:NLog.LogEventInfo.Exception"/>
             </summary>
        </member>
        <member name="T:NLog.Config.NameBaseAttribute">
            <summary>
            Attaches a type-alias for an item (such as <see cref="T:NLog.Targets.Target"/>,
            <see cref="T:NLog.LayoutRenderers.LayoutRenderer"/>, <see cref="T:NLog.Layouts.Layout"/>, etc.).
            </summary>
        </member>
        <member name="M:NLog.Config.NameBaseAttribute.#ctor(System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Config.NameBaseAttribute" /> class.
            </summary>
            <param name="name">The type-alias for use in NLog configuration.</param>
        </member>
        <member name="P:NLog.Config.NameBaseAttribute.Name">
            <summary>
            Gets the name of the type-alias
            </summary>
        </member>
        <member name="T:NLog.Config.NLogConfigurationIgnorePropertyAttribute">
            <summary>
            Indicates NLog should not scan this property during configuration.
            </summary>
        </member>
        <member name="M:NLog.Config.NLogConfigurationIgnorePropertyAttribute.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Config.NLogConfigurationIgnorePropertyAttribute"/> class.
            </summary>
        </member>
        <member name="T:NLog.Config.NLogConfigurationItemAttribute">
            <summary>
            Marks the object as configuration item for NLog.
            </summary>
        </member>
        <member name="M:NLog.Config.NLogConfigurationItemAttribute.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Config.NLogConfigurationItemAttribute"/> class.
            </summary>
        </member>
        <member name="T:NLog.Config.NLogDependencyResolveException">
            <summary>
            Failed to resolve the interface of service type
            </summary>
        </member>
        <member name="P:NLog.Config.NLogDependencyResolveException.ServiceType">
            <summary>
            Typed we tried to resolve
            </summary>
        </member>
        <member name="M:NLog.Config.NLogDependencyResolveException.#ctor(System.String,System.Type)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Config.NLogDependencyResolveException" /> class.
            </summary>
        </member>
        <member name="M:NLog.Config.NLogDependencyResolveException.#ctor(System.String,System.Exception,System.Type)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Config.NLogDependencyResolveException" /> class.
            </summary>
        </member>
        <member name="T:NLog.Config.PropertyTypeConverter">
            <summary>
            Default implementation of <see cref="T:NLog.Config.IPropertyTypeConverter"/>
            </summary>
        </member>
        <member name="P:NLog.Config.PropertyTypeConverter.Instance">
            <summary>
            Singleton instance of the serializer.
            </summary>
        </member>
        <member name="M:NLog.Config.PropertyTypeConverter.Convert(System.Object,System.Type,System.String,System.IFormatProvider)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.Config.RequiredParameterAttribute">
            <summary>
            Attribute used to mark the required parameters for targets,
            layout targets and filters.
            </summary>
        </member>
        <member name="T:NLog.Config.ServiceRepository">
            <summary>
            Interface to register available configuration objects type
            </summary>
        </member>
        <member name="M:NLog.Config.ServiceRepository.RegisterService(System.Type,System.Object)">
            <summary>
            Registers instance of singleton object for use in NLog
            </summary>
            <param name="type">Type of service/interface to register</param>
            <param name="instance">Instance of service</param>
        </member>
        <member name="M:NLog.Config.ServiceRepository.GetService(System.Type)">
            <summary>
            Gets the service object of the specified type.
            </summary>
            <remarks>Avoid calling this while handling a LogEvent, since random deadlocks can occur.</remarks>
        </member>
        <member name="M:NLog.Config.ServiceRepositoryExtensions.RegisterSingleton``1(NLog.Config.ServiceRepository,``0)">
            <summary>
            Registers singleton-object as implementation of specific interface.
            </summary>
            <remarks>
            If the same single-object implements multiple interfaces then it must be registered for each interface
            </remarks>
            <typeparam name="T">Type of interface</typeparam>
            <param name="serviceRepository">The repo</param>
            <param name="singleton">Singleton object to use for override</param>
        </member>
        <member name="M:NLog.Config.ServiceRepositoryExtensions.RegisterValueFormatter(NLog.Config.ServiceRepository,NLog.IValueFormatter)">
            <summary>
            Registers the string serializer to use with <see cref="P:NLog.LogEventInfo.MessageTemplateParameters"/>
            </summary>
        </member>
        <member name="T:NLog.Config.ServiceRepositoryInternal">
            <summary>
            Repository of interfaces used by NLog to allow override for dependency injection
            </summary>
        </member>
        <member name="M:NLog.Config.ServiceRepositoryInternal.#ctor(System.Boolean)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Config.ServiceRepositoryInternal"/> class.
            </summary>
        </member>
        <member name="T:NLog.Config.ServiceRepositoryUpdateEventArgs">
            <summary>
            Registered service type in the service repository
            </summary>
        </member>
        <member name="M:NLog.Config.ServiceRepositoryUpdateEventArgs.#ctor(System.Type)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Config.ServiceRepositoryUpdateEventArgs" /> class.
            </summary>
            <param name="serviceType">Type of service that have been registered</param>
        </member>
        <member name="P:NLog.Config.ServiceRepositoryUpdateEventArgs.ServiceType">
            <summary>
            Type of service-interface that has been registered
            </summary>
        </member>
        <member name="T:NLog.Config.SimpleConfigurator">
             <summary>
             Obsolete and replaced by <see cref="M:NLog.LogManager.Setup"/> with NLog v5.2.
            
             Provides simple programmatic configuration API used for trivial logging cases.
            
             Warning, these methods will overwrite the current config.
             </summary>
        </member>
        <member name="M:NLog.Config.SimpleConfigurator.ConfigureForConsoleLogging">
             <summary>
             Obsolete and replaced by <see cref="M:NLog.LogManager.Setup"/> and <see cref="M:NLog.SetupLoadConfigurationExtensions.WriteToConsole(NLog.Config.ISetupConfigurationTargetBuilder,NLog.Layouts.Layout,System.Text.Encoding,System.Boolean,System.Boolean,System.Boolean)"/> with NLog v5.2.
            
             Configures NLog for console logging so that all messages above and including
             the <see cref="F:NLog.LogLevel.Info"/> level are output to the console.
             </summary>
        </member>
        <member name="M:NLog.Config.SimpleConfigurator.ConfigureForConsoleLogging(NLog.LogLevel)">
             <summary>
             Obsolete and replaced by <see cref="M:NLog.LogManager.Setup"/> and <see cref="M:NLog.SetupLoadConfigurationExtensions.WriteToConsole(NLog.Config.ISetupConfigurationTargetBuilder,NLog.Layouts.Layout,System.Text.Encoding,System.Boolean,System.Boolean,System.Boolean)"/> with NLog v5.2.
            
             Configures NLog for console logging so that all messages above and including
             the specified level are output to the console.
             </summary>
             <param name="minLevel">The minimal logging level.</param>
        </member>
        <member name="M:NLog.Config.SimpleConfigurator.ConfigureForTargetLogging(NLog.Targets.Target)">
             <summary>
             Obsolete and replaced by <see cref="M:NLog.LogManager.Setup"/> with NLog v5.2.
            
             Configures NLog for to log to the specified target so that all messages
             above and including the <see cref="F:NLog.LogLevel.Info"/> level are output.
             </summary>
             <param name="target">The target to log all messages to.</param>
        </member>
        <member name="M:NLog.Config.SimpleConfigurator.ConfigureForTargetLogging(NLog.Targets.Target,NLog.LogLevel)">
             <summary>
             Obsolete and replaced by <see cref="M:NLog.LogManager.Setup"/> with NLog v5.2.
            
             Configures NLog for to log to the specified target so that all messages
             above and including the specified level are output.
             </summary>
             <param name="target">The target to log all messages to.</param>
             <param name="minLevel">The minimal logging level.</param>
        </member>
        <member name="M:NLog.Config.SimpleConfigurator.ConfigureForFileLogging(System.String)">
             <summary>
             Obsolete and replaced by <see cref="M:NLog.LogManager.Setup"/> and <see cref="M:NLog.SetupLoadConfigurationExtensions.WriteToFile(NLog.Config.ISetupConfigurationTargetBuilder,NLog.Layouts.Layout,NLog.Layouts.Layout,System.Text.Encoding,NLog.Targets.LineEndingMode,System.Boolean,System.Int64,System.Int32,System.Int32)"/> with NLog v5.2.
            
             Configures NLog for file logging so that all messages above and including
             the <see cref="F:NLog.LogLevel.Info"/> level are written to the specified file.
             </summary>
             <param name="fileName">Log file name.</param>
        </member>
        <member name="M:NLog.Config.SimpleConfigurator.ConfigureForFileLogging(System.String,NLog.LogLevel)">
             <summary>
             Obsolete and replaced by <see cref="M:NLog.LogManager.Setup"/> and <see cref="M:NLog.SetupLoadConfigurationExtensions.WriteToFile(NLog.Config.ISetupConfigurationTargetBuilder,NLog.Layouts.Layout,NLog.Layouts.Layout,System.Text.Encoding,NLog.Targets.LineEndingMode,System.Boolean,System.Int64,System.Int32,System.Int32)"/> with NLog v5.2.
            
             Configures NLog for file logging so that all messages above and including
             the specified level are written to the specified file.
             </summary>
             <param name="fileName">Log file name.</param>
             <param name="minLevel">The minimal logging level.</param>
        </member>
        <member name="T:NLog.Config.StackTraceUsage">
            <summary>
            Value indicating how stack trace should be captured when processing the log event.
            </summary>
        </member>
        <member name="F:NLog.Config.StackTraceUsage.None">
            <summary>
            No Stack trace needs to be captured.
            </summary>
        </member>
        <member name="F:NLog.Config.StackTraceUsage.WithStackTrace">
            <summary>
            Stack trace should be captured. This option won't add the filenames and linenumbers
            </summary>
        </member>
        <member name="F:NLog.Config.StackTraceUsage.WithFileNameAndLineNumber">
            <summary>
            Capture also filenames and linenumbers
            </summary>
        </member>
        <member name="F:NLog.Config.StackTraceUsage.WithCallSite">
            <summary>
            Capture the location of the call
            </summary>
        </member>
        <member name="F:NLog.Config.StackTraceUsage.WithCallSiteClassName">
            <summary>
            Capture the class name for location of the call
            </summary>
        </member>
        <member name="F:NLog.Config.StackTraceUsage.WithoutSource">
            <summary>
            Stack trace should be captured. This option won't add the filenames and linenumbers.
            </summary>
        </member>
        <member name="F:NLog.Config.StackTraceUsage.WithSource">
            <summary>
            Stack trace should be captured including filenames and linenumbers.
            </summary>
        </member>
        <member name="F:NLog.Config.StackTraceUsage.Max">
            <summary>
            Capture maximum amount of the stack trace information supported on the platform.
            </summary>
        </member>
        <member name="T:NLog.Config.ThreadAgnosticAttribute">
             <summary>
             Marks the layout or layout renderer as thread independent - it producing correct results
             regardless of the thread it's running on.
            
             Without this attribute everything is rendered on the main thread.
             </summary>
             <remarks>
             If this attribute is set on a layout, it could be rendered on the another thread.
             This could be more efficient as it's skipped when not needed.
            
             If context like <c>HttpContext.Current</c> is needed, which is only available on the main thread, this attribute should not be applied.
            
             See the AsyncTargetWrapper and BufferTargetWrapper with the <see cref="M:NLog.Targets.Target.PrecalculateVolatileLayouts(NLog.LogEventInfo)"/> , using <see cref="M:NLog.Layouts.Layout.Precalculate(NLog.LogEventInfo)"/>
            
             Apply this attribute when:
             - The result can we rendered in another thread. Delaying this could be more efficient. And/Or,
             - The result should not be precalculated, for example the target sends some extra context information.
             </remarks>
        </member>
        <member name="T:NLog.Config.ThreadAgnosticImmutableAttribute">
             <summary>
             Marks the layout or layout renderer as thread independent - it producing correct results
             regardless of the thread it's running on.
            
             Layout or layout-renderer depends on <see cref="P:NLog.LogEventInfo.Properties"/> or <see cref="P:NLog.LogEventInfo.Exception"/>,
             and requires that LogEvent-state is recognized as immutable.
             </summary>
             <remarks>
             Must be used in combination with <see cref="T:NLog.Config.ThreadAgnosticAttribute"/>, else it will have no effect
             </remarks>
        </member>
        <member name="T:NLog.Config.ThreadSafeAttribute">
             <summary>
             Marks the layout or layout renderer as thread safe - it producing correct results
             regardless of the number of threads it's running on.
            
             Without this attribute then the target concurrency will be reduced
             </summary>
        </member>
        <member name="T:NLog.Config.XmlLoggingConfiguration">
             <summary>
             A class for configuring NLog through an XML configuration file
             (App.config style or App.nlog style).
            
             Parsing of the XML file is also implemented in this class.
             </summary>
            <remarks>
             - This class is thread-safe.<c>.ToList()</c> is used for that purpose.
             - Update TemplateXSD.xml for changes outside targets
             </remarks>
        </member>
        <member name="M:NLog.Config.XmlLoggingConfiguration.#ctor(System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Config.XmlLoggingConfiguration" /> class.
            </summary>
            <param name="fileName">Configuration file to be read.</param>
        </member>
        <member name="M:NLog.Config.XmlLoggingConfiguration.#ctor(System.String,NLog.LogFactory)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Config.XmlLoggingConfiguration" /> class.
            </summary>
            <param name="fileName">Configuration file to be read.</param>
            <param name="logFactory">The <see cref="T:NLog.LogFactory" /> to which to apply any applicable configuration values.</param>
        </member>
        <member name="M:NLog.Config.XmlLoggingConfiguration.#ctor(System.String,System.Boolean)">
             <summary>
             Obsolete and replaced by <see cref="M:NLog.Config.XmlLoggingConfiguration.#ctor(System.String)"/> with NLog v4.7.
            
             Initializes a new instance of the <see cref="T:NLog.Config.XmlLoggingConfiguration" /> class.
             </summary>
             <param name="fileName">Configuration file to be read.</param>
             <param name="ignoreErrors">Ignore any errors during configuration.</param>
        </member>
        <member name="M:NLog.Config.XmlLoggingConfiguration.#ctor(System.String,System.Boolean,NLog.LogFactory)">
             <summary>
             Obsolete and replaced by <see cref="M:NLog.Config.XmlLoggingConfiguration.#ctor(System.String,NLog.LogFactory)"/> with NLog v4.7.
            
             Initializes a new instance of the <see cref="T:NLog.Config.XmlLoggingConfiguration" /> class.
             </summary>
             <param name="fileName">Configuration file to be read.</param>
             <param name="ignoreErrors">Ignore any errors during configuration.</param>
             <param name="logFactory">The <see cref="T:NLog.LogFactory" /> to which to apply any applicable configuration values.</param>
        </member>
        <member name="M:NLog.Config.XmlLoggingConfiguration.#ctor(System.Xml.XmlReader)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Config.XmlLoggingConfiguration" /> class.
            </summary>
            <param name="reader">XML reader to read from.</param>
        </member>
        <member name="M:NLog.Config.XmlLoggingConfiguration.#ctor(System.Xml.XmlReader,System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Config.XmlLoggingConfiguration" /> class.
            </summary>
            <param name="reader"><see cref="T:System.Xml.XmlReader"/> containing the configuration section.</param>
            <param name="fileName">Name of the file that contains the element (to be used as a base for including other files). <c>null</c> is allowed.</param>
        </member>
        <member name="M:NLog.Config.XmlLoggingConfiguration.#ctor(System.Xml.XmlReader,System.String,NLog.LogFactory)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Config.XmlLoggingConfiguration" /> class.
            </summary>
            <param name="reader"><see cref="T:System.Xml.XmlReader"/> containing the configuration section.</param>
            <param name="fileName">Name of the file that contains the element (to be used as a base for including other files). <c>null</c> is allowed.</param>
            <param name="logFactory">The <see cref="T:NLog.LogFactory" /> to which to apply any applicable configuration values.</param>
        </member>
        <member name="M:NLog.Config.XmlLoggingConfiguration.#ctor(System.Xml.XmlReader,System.String,System.Boolean)">
             <summary>
             Obsolete and replaced by <see cref="M:NLog.Config.XmlLoggingConfiguration.#ctor(System.Xml.XmlReader,System.String)"/> with NLog v4.7.
            
             Initializes a new instance of the <see cref="T:NLog.Config.XmlLoggingConfiguration" /> class.
             </summary>
             <param name="reader"><see cref="T:System.Xml.XmlReader"/> containing the configuration section.</param>
             <param name="fileName">Name of the file that contains the element (to be used as a base for including other files). <c>null</c> is allowed.</param>
             <param name="ignoreErrors">Ignore any errors during configuration.</param>
        </member>
        <member name="M:NLog.Config.XmlLoggingConfiguration.#ctor(System.Xml.XmlReader,System.String,System.Boolean,NLog.LogFactory)">
             <summary>
             Obsolete and replaced by <see cref="M:NLog.Config.XmlLoggingConfiguration.#ctor(System.Xml.XmlReader,System.String,NLog.LogFactory)"/> with NLog v4.7.
            
             Initializes a new instance of the <see cref="T:NLog.Config.XmlLoggingConfiguration" /> class.
             </summary>
             <param name="reader"><see cref="T:System.Xml.XmlReader"/> containing the configuration section.</param>
             <param name="fileName">Name of the file that contains the element (to be used as a base for including other files). <c>null</c> is allowed.</param>
             <param name="ignoreErrors">Ignore any errors during configuration.</param>
             <param name="logFactory">The <see cref="T:NLog.LogFactory" /> to which to apply any applicable configuration values.</param>
        </member>
        <member name="M:NLog.Config.XmlLoggingConfiguration.#ctor(System.String,System.String,NLog.LogFactory)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Config.XmlLoggingConfiguration" /> class.
            </summary>
            <param name="xmlContents">NLog configuration as XML string.</param>
            <param name="fileName">Name of the XML file.</param>
            <param name="logFactory">The <see cref="T:NLog.LogFactory" /> to which to apply any applicable configuration values.</param>
        </member>
        <member name="M:NLog.Config.XmlLoggingConfiguration.CreateFromXmlString(System.String)">
            <summary>
            Parse XML string as NLog configuration
            </summary>
            <param name="xml">NLog configuration in XML to be parsed</param>
        </member>
        <member name="M:NLog.Config.XmlLoggingConfiguration.CreateFromXmlString(System.String,NLog.LogFactory)">
            <summary>
            Parse XML string as NLog configuration
            </summary>
            <param name="xml">NLog configuration in XML to be parsed</param>
            <param name="logFactory">NLog LogFactory</param>
        </member>
        <member name="P:NLog.Config.XmlLoggingConfiguration.AppConfig">
            <summary>
            Gets the default <see cref="T:NLog.Config.LoggingConfiguration" /> object by parsing
            the application configuration file (<c>app.exe.config</c>).
            </summary>
        </member>
        <member name="P:NLog.Config.XmlLoggingConfiguration.InitializeSucceeded">
            <summary>
            Did the <see cref="M:NLog.Config.XmlLoggingConfiguration.Initialize(System.Xml.XmlReader,System.String,System.Boolean)"/> Succeeded? <c>true</c>= success, <c>false</c>= error, <c>null</c> = initialize not started yet.
            </summary>
        </member>
        <member name="P:NLog.Config.XmlLoggingConfiguration.AutoReload">
            <summary>
            Gets or sets a value indicating whether all of the configuration files
            should be watched for changes and reloaded automatically when changed.
            </summary>
        </member>
        <member name="P:NLog.Config.XmlLoggingConfiguration.FileNamesToWatch">
            <summary>
            Gets the collection of file names which should be watched for changes by NLog.
            This is the list of configuration files processed.
            If the <c>autoReload</c> attribute is not set it returns empty collection.
            </summary>
        </member>
        <member name="M:NLog.Config.XmlLoggingConfiguration.Reload">
            <summary>
            Re-reads the original configuration file and returns the new <see cref="T:NLog.Config.LoggingConfiguration" /> object.
            </summary>
            <returns>The newly loaded <see cref="T:NLog.Config.XmlLoggingConfiguration" /> instance.</returns>
            <remarks>Must assign the returned object to LogManager.Configuration to activate it</remarks>
        </member>
        <member name="M:NLog.Config.XmlLoggingConfiguration.GetCandidateConfigFilePaths">
             <summary>
             Obsolete and replaced by <see cref="M:NLog.LogManager.Setup"/> and <see cref="M:NLog.SetupBuilderExtensions.LoadConfigurationFromFile(NLog.Config.ISetupBuilder,System.String,System.Boolean)"/> with NLog v5.2.
            
             Get file paths (including filename) for the possible NLog config files.
             </summary>
             <returns>The file paths to the possible config file</returns>
        </member>
        <member name="M:NLog.Config.XmlLoggingConfiguration.SetCandidateConfigFilePaths(System.Collections.Generic.IEnumerable{System.String})">
             <summary>
             Obsolete and replaced by <see cref="M:NLog.LogManager.Setup"/> and <see cref="M:NLog.SetupBuilderExtensions.LoadConfigurationFromFile(NLog.Config.ISetupBuilder,System.String,System.Boolean)"/> with NLog v5.2.
            
             Overwrite the paths (including filename) for the possible NLog config files.
             </summary>
             <param name="filePaths">The file paths to the possible config file</param>
        </member>
        <member name="M:NLog.Config.XmlLoggingConfiguration.ResetCandidateConfigFilePath">
             <summary>
             Obsolete and replaced by <see cref="M:NLog.LogManager.Setup"/> and <see cref="M:NLog.SetupBuilderExtensions.LoadConfigurationFromFile(NLog.Config.ISetupBuilder,System.String,System.Boolean)"/> with NLog v5.2.
            
             Clear the candidate file paths and return to the defaults.
             </summary>
        </member>
        <member name="M:NLog.Config.XmlLoggingConfiguration.CreateFileReader(System.String)">
            <summary>
            Create XML reader for (xml config) file.
            </summary>
            <param name="fileName">filepath</param>
            <returns>reader or <c>null</c> if filename is empty.</returns>
        </member>
        <member name="M:NLog.Config.XmlLoggingConfiguration.Initialize(System.Xml.XmlReader,System.String,System.Boolean)">
            <summary>
            Initializes the configuration.
            </summary>
            <param name="reader"><see cref="T:System.Xml.XmlReader"/> containing the configuration section.</param>
            <param name="fileName">Name of the file that contains the element (to be used as a base for including other files). <c>null</c> is allowed.</param>
            <param name="ignoreErrors">Ignore any errors during configuration.</param>
        </member>
        <member name="M:NLog.Config.XmlLoggingConfiguration.ConfigureFromFile(System.String,System.Boolean)">
            <summary>
            Add a file with configuration. Check if not already included.
            </summary>
            <param name="fileName"></param>
            <param name="autoReloadDefault"></param>
        </member>
        <member name="M:NLog.Config.XmlLoggingConfiguration.ParseTopLevel(NLog.Config.XmlLoggingConfigurationElement,System.String,System.Boolean)">
            <summary>
            Parse the root
            </summary>
            <param name="content"></param>
            <param name="filePath">path to config file.</param>
            <param name="autoReloadDefault">The default value for the autoReload option.</param>
        </member>
        <member name="M:NLog.Config.XmlLoggingConfiguration.ParseConfigurationElement(NLog.Config.XmlLoggingConfigurationElement,System.String,System.Boolean)">
            <summary>
            Parse {configuration} xml element.
            </summary>
            <param name="configurationElement"></param>
            <param name="filePath">path to config file.</param>
            <param name="autoReloadDefault">The default value for the autoReload option.</param>
        </member>
        <member name="M:NLog.Config.XmlLoggingConfiguration.ParseNLogElement(NLog.Config.ILoggingConfigurationElement,System.String,System.Boolean)">
            <summary>
            Parse {NLog} xml element.
            </summary>
            <param name="nlogElement"></param>
            <param name="filePath">path to config file.</param>
            <param name="autoReloadDefault">The default value for the autoReload option.</param>
        </member>
        <member name="M:NLog.Config.XmlLoggingConfiguration.ParseNLogSection(NLog.Config.ILoggingConfigurationElement)">
            <summary>
            Parses a single config section within the NLog-config
            </summary>
            <param name="configSection"></param>
            <returns>Section was recognized</returns>
        </member>
        <member name="M:NLog.Config.XmlLoggingConfiguration.ConfigureFromFilesByMask(System.String,System.String,System.Boolean)">
            <summary>
            Include (multiple) files by filemask, e.g. *.nlog
            </summary>
            <param name="baseDirectory">base directory in case if <paramref name="fileMask"/> is relative</param>
            <param name="fileMask">relative or absolute fileMask</param>
            <param name="autoReloadDefault"></param>
        </member>
        <member name="M:NLog.Config.XmlLoggingConfiguration.ToString">
            <inheritdoc/>
        </member>
        <member name="T:NLog.Config.XmlLoggingConfigurationElement">
            <summary>
            Represents simple XML element with case-insensitive attribute semantics.
            </summary>
        </member>
        <member name="M:NLog.Config.XmlLoggingConfigurationElement.#ctor(System.Xml.XmlReader)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Config.XmlLoggingConfigurationElement"/> class.
            </summary>
            <param name="reader">The reader to initialize element from.</param>
        </member>
        <member name="P:NLog.Config.XmlLoggingConfigurationElement.LocalName">
            <summary>
            Gets the element name.
            </summary>
        </member>
        <member name="P:NLog.Config.XmlLoggingConfigurationElement.AttributeValues">
            <summary>
            Gets the dictionary of attribute values.
            </summary>
        </member>
        <member name="P:NLog.Config.XmlLoggingConfigurationElement.Children">
            <summary>
            Gets the collection of child elements.
            </summary>
        </member>
        <member name="P:NLog.Config.XmlLoggingConfigurationElement.Value">
            <summary>
            Gets the value of the element.
            </summary>
        </member>
        <member name="M:NLog.Config.XmlLoggingConfigurationElement.FilterChildren(System.String)">
            <summary>
            Returns children elements with the specified element name.
            </summary>
            <param name="elementName">Name of the element.</param>
            <returns>Children elements with the specified element name.</returns>
        </member>
        <member name="M:NLog.Config.XmlLoggingConfigurationElement.AssertName(System.String[])">
            <summary>
            Asserts that the name of the element is among specified element names.
            </summary>
            <param name="allowedNames">The allowed names.</param>
        </member>
        <member name="M:NLog.Config.XmlLoggingConfigurationElement.IsSpecialXmlAttribute(System.Xml.XmlReader)">
            <summary>
            Special attribute we could ignore
            </summary>
        </member>
        <member name="T:NLog.Filters.ConditionBasedFilter">
            <summary>
            Matches when the specified condition is met.
            </summary>
            <remarks>
            Conditions are expressed using a simple language.
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/Conditions">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.Filters.ConditionBasedFilter.Condition">
            <summary>
            Gets or sets the condition expression.
            </summary>
            <docgen category='Filtering Options' order='10' />
        </member>
        <member name="M:NLog.Filters.ConditionBasedFilter.Check(NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.Filters.Filter">
            <summary>
            An abstract filter class. Provides a way to eliminate log messages
            based on properties other than logger name and log level.
            </summary>
        </member>
        <member name="M:NLog.Filters.Filter.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Filters.Filter" /> class.
            </summary>
        </member>
        <member name="P:NLog.Filters.Filter.Action">
            <summary>
            Gets or sets the action to be taken when filter matches.
            </summary>
            <docgen category='Filtering Options' order='10' />
        </member>
        <member name="M:NLog.Filters.Filter.GetFilterResult(NLog.LogEventInfo)">
            <summary>
            Gets the result of evaluating filter against given log event.
            </summary>
            <param name="logEvent">The log event.</param>
            <returns>Filter result.</returns>
        </member>
        <member name="M:NLog.Filters.Filter.Check(NLog.LogEventInfo)">
            <summary>
            Checks whether log event should be logged or not.
            </summary>
            <param name="logEvent">Log event.</param>
            <returns>
            <see cref="F:NLog.Filters.FilterResult.Ignore"/> - if the log event should be ignored<br/>
            <see cref="F:NLog.Filters.FilterResult.Neutral"/> - if the filter doesn't want to decide<br/>
            <see cref="F:NLog.Filters.FilterResult.Log"/> - if the log event should be logged<br/>
            .</returns>
        </member>
        <member name="T:NLog.Filters.FilterAttribute">
            <summary>
            Marks class as a layout renderer and assigns a name to it.
            </summary>
        </member>
        <member name="M:NLog.Filters.FilterAttribute.#ctor(System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Filters.FilterAttribute" /> class.
            </summary>
            <param name="name">Name of the filter.</param>
        </member>
        <member name="T:NLog.Filters.FilterResult">
            <summary>
            Filter result.
            </summary>
        </member>
        <member name="F:NLog.Filters.FilterResult.Neutral">
            <summary>
            The filter doesn't want to decide whether to log or discard the message.
            </summary>
        </member>
        <member name="F:NLog.Filters.FilterResult.Log">
            <summary>
            The message should be logged.
            </summary>
        </member>
        <member name="F:NLog.Filters.FilterResult.Ignore">
            <summary>
            The message should not be logged.
            </summary>
        </member>
        <member name="F:NLog.Filters.FilterResult.LogFinal">
            <summary>
            The message should be logged and processing should be finished.
            </summary>
        </member>
        <member name="F:NLog.Filters.FilterResult.IgnoreFinal">
            <summary>
            The message should not be logged and processing should be finished.
            </summary>
        </member>
        <member name="T:NLog.Filters.LayoutBasedFilter">
            <summary>
            A base class for filters that are based on comparing a value to a layout.
            </summary>
        </member>
        <member name="M:NLog.Filters.LayoutBasedFilter.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Filters.LayoutBasedFilter" /> class.
            </summary>
        </member>
        <member name="P:NLog.Filters.LayoutBasedFilter.Layout">
            <summary>
            Gets or sets the layout to be used to filter log messages.
            </summary>
            <value>The layout.</value>
            <docgen category='Filtering Options' order='10' />
        </member>
        <member name="T:NLog.Filters.WhenContainsFilter">
            <summary>
            Matches when the calculated layout contains the specified substring.
            This filter is deprecated in favor of <c>&lt;when /&gt;</c> which is based on <a href="https://github.com/NLog/NLog/wiki/Conditions">conditions</a>.
            </summary>
        </member>
        <member name="P:NLog.Filters.WhenContainsFilter.IgnoreCase">
            <summary>
            Gets or sets a value indicating whether to ignore case when comparing strings.
            </summary>
            <docgen category='Filtering Options' order='10' />
        </member>
        <member name="P:NLog.Filters.WhenContainsFilter.Substring">
            <summary>
            Gets or sets the substring to be matched.
            </summary>
            <docgen category='Filtering Options' order='10' />
        </member>
        <member name="M:NLog.Filters.WhenContainsFilter.Check(NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.Filters.WhenEqualFilter">
            <summary>
            Matches when the calculated layout is equal to the specified substring.
            This filter is deprecated in favor of <c>&lt;when /&gt;</c> which is based on <a href="https://github.com/NLog/NLog/wiki/Conditions">conditions</a>.
            </summary>
        </member>
        <member name="P:NLog.Filters.WhenEqualFilter.IgnoreCase">
            <summary>
            Gets or sets a value indicating whether to ignore case when comparing strings.
            </summary>
            <docgen category='Filtering Options' order='10' />
        </member>
        <member name="P:NLog.Filters.WhenEqualFilter.CompareTo">
            <summary>
            Gets or sets a string to compare the layout to.
            </summary>
            <docgen category='Filtering Options' order='10' />
        </member>
        <member name="M:NLog.Filters.WhenEqualFilter.Check(NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.Filters.WhenMethodFilter">
            <summary>
            Matches the provided filter-method
            </summary>
        </member>
        <member name="M:NLog.Filters.WhenMethodFilter.#ctor(System.Func{NLog.LogEventInfo,NLog.Filters.FilterResult})">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Filters.WhenMethodFilter" /> class.
            </summary>
        </member>
        <member name="M:NLog.Filters.WhenMethodFilter.Check(NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.Filters.WhenNotContainsFilter">
            <summary>
            Matches when the calculated layout does NOT contain the specified substring.
            This filter is deprecated in favor of <c>&lt;when /&gt;</c> which is based on <a href="https://github.com/NLog/NLog/wiki/Conditions">conditions</a>.
            </summary>
        </member>
        <member name="P:NLog.Filters.WhenNotContainsFilter.Substring">
            <summary>
            Gets or sets the substring to be matched.
            </summary>
            <docgen category='Filtering Options' order='10' />
        </member>
        <member name="P:NLog.Filters.WhenNotContainsFilter.IgnoreCase">
            <summary>
            Gets or sets a value indicating whether to ignore case when comparing strings.
            </summary>
            <docgen category='Filtering Options' order='10' />
        </member>
        <member name="M:NLog.Filters.WhenNotContainsFilter.Check(NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.Filters.WhenNotEqualFilter">
            <summary>
            Matches when the calculated layout is NOT equal to the specified substring.
            This filter is deprecated in favor of <c>&lt;when /&gt;</c> which is based on <a href="https://github.com/NLog/NLog/wiki/Conditions">conditions</a>.
            </summary>
        </member>
        <member name="M:NLog.Filters.WhenNotEqualFilter.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Filters.WhenNotEqualFilter" /> class.
            </summary>
        </member>
        <member name="P:NLog.Filters.WhenNotEqualFilter.CompareTo">
            <summary>
            Gets or sets a string to compare the layout to.
            </summary>
            <docgen category='Filtering Options' order='10' />
        </member>
        <member name="P:NLog.Filters.WhenNotEqualFilter.IgnoreCase">
            <summary>
            Gets or sets a value indicating whether to ignore case when comparing strings.
            </summary>
            <docgen category='Filtering Options' order='10' />
        </member>
        <member name="M:NLog.Filters.WhenNotEqualFilter.Check(NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.Filters.WhenRepeatedFilter">
            <summary>
            Matches when the result of the calculated layout has been repeated a moment ago
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/WhenRepeated-Filter">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/WhenRepeated-Filter">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.Filters.WhenRepeatedFilter.TimeoutSeconds">
            <summary>
            How long before a filter expires, and logging is accepted again
            </summary>
            <docgen category='Filtering Options' order='10' />
        </member>
        <member name="P:NLog.Filters.WhenRepeatedFilter.MaxLength">
            <summary>
            Max length of filter values, will truncate if above limit
            </summary>
            <docgen category='Filtering Options' order='10' />
        </member>
        <member name="P:NLog.Filters.WhenRepeatedFilter.IncludeFirst">
            <summary>
            Applies the configured action to the initial logevent that starts the timeout period.
            Used to configure that it should ignore all events until timeout.
            </summary>
            <docgen category='Filtering Options' order='10' />
        </member>
        <member name="P:NLog.Filters.WhenRepeatedFilter.MaxFilterCacheSize">
            <summary>
            Max number of unique filter values to expect simultaneously
            </summary>
            <docgen category='Filtering Options' order='100' />
        </member>
        <member name="P:NLog.Filters.WhenRepeatedFilter.DefaultFilterCacheSize">
            <summary>
            Default number of unique filter values to expect, will automatically increase if needed
            </summary>
            <docgen category='Filtering Options' order='100' />
        </member>
        <member name="P:NLog.Filters.WhenRepeatedFilter.FilterCountPropertyName">
            <summary>
            Insert FilterCount value into <see cref="P:NLog.LogEventInfo.Properties"/> when an event is no longer filtered
            </summary>
            <docgen category='Filtering Options' order='10' />
        </member>
        <member name="P:NLog.Filters.WhenRepeatedFilter.FilterCountMessageAppendFormat">
            <summary>
            Append FilterCount to the <see cref="P:NLog.LogEventInfo.Message"/> when an event is no longer filtered
            </summary>
            <docgen category='Filtering Options' order='10' />
        </member>
        <member name="P:NLog.Filters.WhenRepeatedFilter.OptimizeBufferReuse">
            <summary>
            Reuse internal buffers, and doesn't have to constantly allocate new buffers
            </summary>
            <docgen category='Filtering Options' order='100' />
        </member>
        <member name="P:NLog.Filters.WhenRepeatedFilter.OptimizeBufferDefaultLength">
            <summary>
            Default buffer size for the internal buffers
            </summary>
            <docgen category='Filtering Options' order='100' />
        </member>
        <member name="M:NLog.Filters.WhenRepeatedFilter.Check(NLog.LogEventInfo)">
            <summary>
            Checks whether log event should be logged or not. In case the LogEvent has just been repeated.
            </summary>
            <param name="logEvent">Log event.</param>
            <returns>
            <see cref="F:NLog.Filters.FilterResult.Ignore"/> - if the log event should be ignored<br/>
            <see cref="F:NLog.Filters.FilterResult.Neutral"/> - if the filter doesn't want to decide<br/>
            <see cref="F:NLog.Filters.FilterResult.Log"/> - if the log event should be logged<br/>
            .</returns>
        </member>
        <member name="M:NLog.Filters.WhenRepeatedFilter.CreateFilterInfo(NLog.LogEventInfo)">
            <summary>
            Uses object pooling, and prunes stale filter items when the pool runs dry
            </summary>
        </member>
        <member name="M:NLog.Filters.WhenRepeatedFilter.PruneFilterCache(NLog.LogEventInfo,System.Int32)">
            <summary>
            Remove stale filter-value from the cache, and fill them into the pool for reuse
            </summary>
        </member>
        <member name="M:NLog.Filters.WhenRepeatedFilter.RenderFilterInfoKey(NLog.LogEventInfo,System.Text.StringBuilder)">
            <summary>
            Renders the Log Event into a filter value, that is used for checking if just repeated
            </summary>
        </member>
        <member name="M:NLog.Filters.WhenRepeatedFilter.RefreshFilterInfo(NLog.LogEventInfo,NLog.Filters.WhenRepeatedFilter.FilterInfo)">
            <summary>
            Repeated LogEvent detected. Checks if it should activate filter-action
            </summary>
        </member>
        <member name="T:NLog.Filters.WhenRepeatedFilter.FilterInfo">
            <summary>
            Filter Value State (mutable)
            </summary>
        </member>
        <member name="T:NLog.Filters.WhenRepeatedFilter.FilterInfoKey">
            <summary>
            Filter Lookup Key (immutable)
            </summary>
        </member>
        <member name="T:NLog.Fluent.Log">
            <summary>
            A global logging class using caller info to find the logger.
            </summary>
        </member>
        <member name="M:NLog.Fluent.Log.Level(NLog.LogLevel,System.String)">
             <summary>
             Obsolete and replaced by <see cref="M:NLog.ILoggerExtensions.ForLogEvent(NLog.ILogger,NLog.LogLevel)"/> with NLog v5.
            
             Starts building a log event with the specified <see cref="T:System.LogLevel" />.
             </summary>
             <param name="logLevel">The log level.</param>
             <param name="callerFilePath">The full path of the source file that contains the caller. This is the file path at the time of compile.</param>
             <returns>An instance of the fluent <see cref="T:NLog.Fluent.LogBuilder"/>.</returns>
        </member>
        <member name="M:NLog.Fluent.Log.Trace(System.String)">
             <summary>
             Obsolete and replaced by <see cref="M:NLog.ILoggerExtensions.ForTraceEvent(NLog.ILogger)"/> with NLog v5.
            
             Starts building a log event at the <c>Trace</c> level.
             </summary>
             <param name="callerFilePath">The full path of the source file that contains the caller. This is the file path at the time of compile.</param>
             <returns>An instance of the fluent <see cref="T:NLog.Fluent.LogBuilder"/>.</returns>
        </member>
        <member name="M:NLog.Fluent.Log.Debug(System.String)">
             <summary>
             Obsolete and replaced by <see cref="M:NLog.ILoggerExtensions.ForDebugEvent(NLog.ILogger)"/> with NLog v5.
            
             Starts building a log event at the <c>Debug</c> level.
             </summary>
             <param name="callerFilePath">The full path of the source file that contains the caller. This is the file path at the time of compile.</param>
             <returns>An instance of the fluent <see cref="T:NLog.Fluent.LogBuilder"/>.</returns>
        </member>
        <member name="M:NLog.Fluent.Log.Info(System.String)">
             <summary>
             Obsolete and replaced by <see cref="M:NLog.ILoggerExtensions.ForInfoEvent(NLog.ILogger)"/> with NLog v5.
            
             Starts building a log event at the <c>Info</c> level.
             </summary>
             <param name="callerFilePath">The full path of the source file that contains the caller. This is the file path at the time of compile.</param>
             <returns>An instance of the fluent <see cref="T:NLog.Fluent.LogBuilder"/>.</returns>
        </member>
        <member name="M:NLog.Fluent.Log.Warn(System.String)">
             <summary>
             Obsolete and replaced by <see cref="M:NLog.ILoggerExtensions.ForWarnEvent(NLog.ILogger)"/> with NLog v5.
            
             Starts building a log event at the <c>Warn</c> level.
             </summary>
             <param name="callerFilePath">The full path of the source file that contains the caller. This is the file path at the time of compile.</param>
             <returns>An instance of the fluent <see cref="T:NLog.Fluent.LogBuilder"/>.</returns>
        </member>
        <member name="M:NLog.Fluent.Log.Error(System.String)">
             <summary>
             Obsolete and replaced by <see cref="M:NLog.ILoggerExtensions.ForErrorEvent(NLog.ILogger)"/> with NLog v5.
            
             Starts building a log event at the <c>Error</c> level.
             </summary>
             <param name="callerFilePath">The full path of the source file that contains the caller. This is the file path at the time of compile.</param>
             <returns>An instance of the fluent <see cref="T:NLog.Fluent.LogBuilder"/>.</returns>
        </member>
        <member name="M:NLog.Fluent.Log.Fatal(System.String)">
             <summary>
             Obsolete and replaced by <see cref="M:NLog.ILoggerExtensions.ForFatalEvent(NLog.ILogger)"/> with NLog v5.
            
             Starts building a log event at the <c>Fatal</c> level.
             </summary>
             <param name="callerFilePath">The full path of the source file that contains the caller. This is the file path at the time of compile.</param>
             <returns>An instance of the fluent <see cref="T:NLog.Fluent.LogBuilder"/>.</returns>
        </member>
        <member name="T:NLog.Fluent.LogBuilder">
             <summary>
             Obsolete and replaced by <see cref="T:NLog.LogEventBuilder"/> with NLog v5.
            
             A fluent class to build log events for NLog.
             </summary>
        </member>
        <member name="M:NLog.Fluent.LogBuilder.#ctor(NLog.ILogger)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Fluent.LogBuilder"/> class.
            </summary>
            <param name="logger">The <see cref="T:NLog.Logger"/> to send the log event.</param>
        </member>
        <member name="M:NLog.Fluent.LogBuilder.#ctor(NLog.ILogger,NLog.LogLevel)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Fluent.LogBuilder"/> class.
            </summary>
            <param name="logger">The <see cref="T:NLog.Logger"/> to send the log event.</param>
            <param name="logLevel">The <see cref="T:NLog.LogLevel"/> for the log event.</param>
        </member>
        <member name="P:NLog.Fluent.LogBuilder.LogEventInfo">
            <summary>
            Gets the <see cref="P:NLog.Fluent.LogBuilder.LogEventInfo"/> created by the builder.
            </summary>
        </member>
        <member name="M:NLog.Fluent.LogBuilder.Exception(System.Exception)">
            <summary>
            Sets the <paramref name="exception"/> information of the logging event.
            </summary>
            <param name="exception">The exception information of the logging event.</param>
            <returns>current <see cref="T:NLog.Fluent.LogBuilder"/> for chaining calls.</returns>
        </member>
        <member name="M:NLog.Fluent.LogBuilder.Level(NLog.LogLevel)">
            <summary>
            Sets the level of the logging event.
            </summary>
            <param name="logLevel">The level of the logging event.</param>
            <returns>current <see cref="T:NLog.Fluent.LogBuilder"/> for chaining calls.</returns>
        </member>
        <member name="M:NLog.Fluent.LogBuilder.LoggerName(System.String)">
            <summary>
            Sets the logger name of the logging event.
            </summary>
            <param name="loggerName">The logger name of the logging event.</param>
            <returns>current <see cref="T:NLog.Fluent.LogBuilder"/> for chaining calls.</returns>
        </member>
        <member name="M:NLog.Fluent.LogBuilder.Message(System.String)">
            <summary>
            Sets the log message on the logging event.
            </summary>
            <param name="message">The log message for the logging event.</param>
            <returns>current <see cref="T:NLog.Fluent.LogBuilder"/> for chaining calls.</returns>
        </member>
        <member name="M:NLog.Fluent.LogBuilder.Message(System.String,System.Object)">
            <summary>
            Sets the log message and parameters for formatting on the logging event.
            </summary>
            <param name="format">A composite format string.</param>
            <param name="arg0">The object to format.</param>
            <returns>current <see cref="T:NLog.Fluent.LogBuilder"/> for chaining calls.</returns>
        </member>
        <member name="M:NLog.Fluent.LogBuilder.Message(System.String,System.Object,System.Object)">
            <summary>
            Sets the log message and parameters for formatting on the logging event.
            </summary>
            <param name="format">A composite format string.</param>
            <param name="arg0">The first object to format.</param>
            <param name="arg1">The second object to format.</param>
            <returns>current <see cref="T:NLog.Fluent.LogBuilder"/> for chaining calls.</returns>
        </member>
        <member name="M:NLog.Fluent.LogBuilder.Message(System.String,System.Object,System.Object,System.Object)">
            <summary>
            Sets the log message and parameters for formatting on the logging event.
            </summary>
            <param name="format">A composite format string.</param>
            <param name="arg0">The first object to format.</param>
            <param name="arg1">The second object to format.</param>
            <param name="arg2">The third object to format.</param>
            <returns>current <see cref="T:NLog.Fluent.LogBuilder"/> for chaining calls.</returns>
        </member>
        <member name="M:NLog.Fluent.LogBuilder.Message(System.String,System.Object,System.Object,System.Object,System.Object)">
            <summary>
            Sets the log message and parameters for formatting on the logging event.
            </summary>
            <param name="format">A composite format string.</param>
            <param name="arg0">The first object to format.</param>
            <param name="arg1">The second object to format.</param>
            <param name="arg2">The third object to format.</param>
            <param name="arg3">The fourth object to format.</param>
            <returns>current <see cref="T:NLog.Fluent.LogBuilder"/> for chaining calls.</returns>
        </member>
        <member name="M:NLog.Fluent.LogBuilder.Message(System.String,System.Object[])">
            <summary>
            Sets the log message and parameters for formatting on the logging event.
            </summary>
            <param name="format">A composite format string.</param>
            <param name="args">An object array that contains zero or more objects to format.</param>
            <returns>current <see cref="T:NLog.Fluent.LogBuilder"/> for chaining calls.</returns>
        </member>
        <member name="M:NLog.Fluent.LogBuilder.Message(System.IFormatProvider,System.String,System.Object[])">
            <summary>
            Sets the log message and parameters for formatting on the logging event.
            </summary>
            <param name="provider">An object that supplies culture-specific formatting information.</param>
            <param name="format">A composite format string.</param>
            <param name="args">An object array that contains zero or more objects to format.</param>
            <returns>current <see cref="T:NLog.Fluent.LogBuilder"/> for chaining calls.</returns>
        </member>
        <member name="M:NLog.Fluent.LogBuilder.Property(System.Object,System.Object)">
            <summary>
            Sets a per-event context property on the logging event.
            </summary>
            <param name="name">The name of the context property.</param>
            <param name="value">The value of the context property.</param>
            <returns>current <see cref="T:NLog.Fluent.LogBuilder"/> for chaining calls.</returns>
        </member>
        <member name="M:NLog.Fluent.LogBuilder.Properties(System.Collections.IDictionary)">
            <summary>
            Sets multiple per-event context properties on the logging event.
            </summary>
            <param name="properties">The properties to set.</param>
            <returns>current <see cref="T:NLog.Fluent.LogBuilder"/> for chaining calls.</returns>
        </member>
        <member name="M:NLog.Fluent.LogBuilder.TimeStamp(System.DateTime)">
            <summary>
            Sets the timestamp of the logging event.
            </summary>
            <param name="timeStamp">The timestamp of the logging event.</param>
            <returns>current <see cref="T:NLog.Fluent.LogBuilder"/> for chaining calls.</returns>
        </member>
        <member name="M:NLog.Fluent.LogBuilder.StackTrace(System.Diagnostics.StackTrace,System.Int32)">
            <summary>
            Sets the stack trace for the event info.
            </summary>
            <param name="stackTrace">The stack trace.</param>
            <param name="userStackFrame">Index of the first user stack frame within the stack trace.</param>
            <returns>current <see cref="T:NLog.Fluent.LogBuilder"/> for chaining calls.</returns>
        </member>
        <member name="M:NLog.Fluent.LogBuilder.Write(System.String,System.String,System.Int32)">
            <summary>
            Writes the log event to the underlying logger.
            </summary>
            <param name="callerMemberName">The method or property name of the caller to the method. This is set at by the compiler.</param>
            <param name="callerFilePath">The full path of the source file that contains the caller. This is set at by the compiler.</param>
            <param name="callerLineNumber">The line number in the source file at which the method is called. This is set at by the compiler.</param>
        </member>
        <member name="M:NLog.Fluent.LogBuilder.WriteIf(System.Func{System.Boolean},System.String,System.String,System.Int32)">
            <summary>
            Writes the log event to the underlying logger if the condition delegate is true.
            </summary>
            <param name="condition">If condition is true, write log event; otherwise ignore event.</param>
            <param name="callerMemberName">The method or property name of the caller to the method. This is set at by the compiler.</param>
            <param name="callerFilePath">The full path of the source file that contains the caller. This is set at by the compiler.</param>
            <param name="callerLineNumber">The line number in the source file at which the method is called. This is set at by the compiler.</param>
        </member>
        <member name="M:NLog.Fluent.LogBuilder.WriteIf(System.Boolean,System.String,System.String,System.Int32)">
            <summary>
            Writes the log event to the underlying logger if the condition is true.
            </summary>
            <param name="condition">If condition is true, write log event; otherwise ignore event.</param>
            <param name="callerMemberName">The method or property name of the caller to the method. This is set at by the compiler.</param>
            <param name="callerFilePath">The full path of the source file that contains the caller. This is set at by the compiler.</param>
            <param name="callerLineNumber">The line number in the source file at which the method is called. This is set at by the compiler.</param>
        </member>
        <member name="T:NLog.Fluent.LoggerExtensions">
            <summary>
            Extension methods for NLog <see cref="T:NLog.Logger"/>.
            </summary>
        </member>
        <member name="M:NLog.Fluent.LoggerExtensions.Log(NLog.ILogger,NLog.LogLevel)">
             <summary>
             Obsolete and replaced by <see cref="M:NLog.ILoggerExtensions.ForLogEvent(NLog.ILogger,NLog.LogLevel)"/> with NLog v5.
            
             Starts building a log event with the specified <see cref="T:NLog.LogLevel"/>.
             </summary>
             <param name="logger">The logger to write the log event to.</param>
             <param name="logLevel">The log level.</param>
             <returns>current <see cref="T:NLog.Fluent.LogBuilder"/> for chaining calls.</returns>
        </member>
        <member name="M:NLog.Fluent.LoggerExtensions.Trace(NLog.ILogger)">
             <summary>
             Obsolete and replaced by <see cref="M:NLog.ILoggerExtensions.ForTraceEvent(NLog.ILogger)"/> with NLog v5.
            
             Starts building a log event at the <c>Trace</c> level.
             </summary>
             <param name="logger">The logger to write the log event to.</param>
             <returns>current <see cref="T:NLog.Fluent.LogBuilder"/> for chaining calls.</returns>
        </member>
        <member name="M:NLog.Fluent.LoggerExtensions.Debug(NLog.ILogger)">
             <summary>
             Obsolete and replaced by <see cref="M:NLog.ILoggerExtensions.ForDebugEvent(NLog.ILogger)"/> with NLog v5.
            
             Starts building a log event at the <c>Debug</c> level.
             </summary>
             <param name="logger">The logger to write the log event to.</param>
             <returns>current <see cref="T:NLog.Fluent.LogBuilder"/> for chaining calls.</returns>
        </member>
        <member name="M:NLog.Fluent.LoggerExtensions.Info(NLog.ILogger)">
             <summary>
             Obsolete and replaced by <see cref="M:NLog.ILoggerExtensions.ForInfoEvent(NLog.ILogger)"/> with NLog v5.
            
             Starts building a log event at the <c>Info</c> level.
             </summary>
             <param name="logger">The logger to write the log event to.</param>
             <returns>current <see cref="T:NLog.Fluent.LogBuilder"/> for chaining calls.</returns>
        </member>
        <member name="M:NLog.Fluent.LoggerExtensions.Warn(NLog.ILogger)">
             <summary>
             Obsolete and replaced by <see cref="M:NLog.ILoggerExtensions.ForWarnEvent(NLog.ILogger)"/> with NLog v5.
            
             Starts building a log event at the <c>Warn</c> level.
             </summary>
             <param name="logger">The logger to write the log event to.</param>
             <returns>current <see cref="T:NLog.Fluent.LogBuilder"/> for chaining calls.</returns>
        </member>
        <member name="M:NLog.Fluent.LoggerExtensions.Error(NLog.ILogger)">
             <summary>
             Obsolete and replaced by <see cref="M:NLog.ILoggerExtensions.ForErrorEvent(NLog.ILogger)"/> with NLog v5.
            
             Starts building a log event at the <c>Error</c> level.
             </summary>
             <param name="logger">The logger to write the log event to.</param>
             <returns>current <see cref="T:NLog.Fluent.LogBuilder"/> for chaining calls.</returns>
        </member>
        <member name="M:NLog.Fluent.LoggerExtensions.Fatal(NLog.ILogger)">
             <summary>
             Obsolete and replaced by <see cref="M:NLog.ILoggerExtensions.ForFatalEvent(NLog.ILogger)"/> with NLog v5.
            
             Starts building a log event at the <c>Fatal</c> level.
             </summary>
             <param name="logger">The logger to write the log event to.</param>
             <returns>current <see cref="T:NLog.Fluent.LogBuilder"/> for chaining calls.</returns>
        </member>
        <member name="T:NLog.GlobalDiagnosticsContext">
            <summary>
            Global Diagnostics Context - a dictionary structure to hold per-application-instance values.
            </summary>
        </member>
        <member name="M:NLog.GlobalDiagnosticsContext.Set(System.String,System.String)">
            <summary>
            Sets the value with the specified key in the Global Diagnostics Context (GDC) dictionary
            </summary>
            <param name="item">Item name.</param>
            <param name="value">Item value.</param>
        </member>
        <member name="M:NLog.GlobalDiagnosticsContext.Set(System.String,System.Object)">
            <summary>
            Sets the value with the specified key in the Global Diagnostics Context (GDC) dictionary
            </summary>
            <param name="item">Item name.</param>
            <param name="value">Item value.</param>
        </member>
        <member name="M:NLog.GlobalDiagnosticsContext.Get(System.String)">
            <summary>
            Gets the value with the specified key in the Global Diagnostics Context (GDC) dictionary
            </summary>
            <param name="item">Item name.</param>
            <returns>The value of <paramref name="item"/>, if defined; otherwise <see cref="F:System.String.Empty"/>.</returns>
            <remarks>If the value isn't a <see cref="T:System.String"/> already, this call locks the <see cref="T:NLog.LogFactory"/> for reading the <see cref="P:NLog.Config.LoggingConfiguration.DefaultCultureInfo"/> needed for converting to <see cref="T:System.String"/>. </remarks>
        </member>
        <member name="M:NLog.GlobalDiagnosticsContext.Get(System.String,System.IFormatProvider)">
            <summary>
            Gets the value with the specified key in the Global Diagnostics Context (GDC) dictionary
            </summary>
            <param name="item">Item name.</param>
            <param name="formatProvider"><see cref="T:System.IFormatProvider"/> to use when converting the item's value to a string.</param>
            <returns>The value of <paramref name="item"/> as a string, if defined; otherwise <see cref="F:System.String.Empty"/>.</returns>
            <remarks>If <paramref name="formatProvider"/> is <c>null</c> and the value isn't a <see cref="T:System.String"/> already, this call locks the <see cref="T:NLog.LogFactory"/> for reading the <see cref="P:NLog.Config.LoggingConfiguration.DefaultCultureInfo"/> needed for converting to <see cref="T:System.String"/>. </remarks>
        </member>
        <member name="M:NLog.GlobalDiagnosticsContext.GetObject(System.String)">
            <summary>
            Gets the value with the specified key in the Global Diagnostics Context (GDC) dictionary
            </summary>
            <param name="item">Item name.</param>
            <returns>The item value, if defined; otherwise <c>null</c>.</returns>
        </member>
        <member name="M:NLog.GlobalDiagnosticsContext.GetNames">
            <summary>
            Gets all key-names from Global Diagnostics Context (GDC) dictionary
            </summary>
            <returns>A collection of the names of all items in the Global Diagnostics Context.</returns>
        </member>
        <member name="M:NLog.GlobalDiagnosticsContext.Contains(System.String)">
            <summary>
            Determines whether the Global Diagnostics Context (GDC) dictionary contains the specified key.
            </summary>
            <param name="item">Item name.</param>
            <returns>A boolean indicating whether the specified item exists in current thread GDC.</returns>
        </member>
        <member name="M:NLog.GlobalDiagnosticsContext.Remove(System.String)">
            <summary>
            Removes the value with the specified key from the Global Diagnostics Context (GDC) dictionary
            </summary>
            <param name="item">Item name.</param>
        </member>
        <member name="M:NLog.GlobalDiagnosticsContext.Clear">
            <summary>
            Clears the content of the Global Diagnostics Context (GDC) dictionary.
            </summary>
        </member>
        <member name="T:NLog.IJsonConverter">
            <summary>
            Interface for serialization of object values into JSON format
            </summary>
        </member>
        <member name="M:NLog.IJsonConverter.SerializeObject(System.Object,System.Text.StringBuilder)">
            <summary>
            Serialization of an object into JSON format.
            </summary>
            <param name="value">The object to serialize to JSON.</param>
            <param name="builder">Output destination.</param>
            <returns>Serialize succeeded (true/false)</returns>
        </member>
        <member name="T:NLog.ILogger">
            <content>
            Auto-generated Logger members for binary compatibility with NLog 1.0.
            </content>
            <summary>
            Provides logging interface and utility functions.
            </summary>
        </member>
        <member name="M:NLog.ILogger.Trace(System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level.
            </summary>
            <param name="value">A <see langword="object" /> to be written.</param>
        </member>
        <member name="M:NLog.ILogger.Trace(System.IFormatProvider,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="value">A <see langword="object" /> to be written.</param>
        </member>
        <member name="M:NLog.ILogger.Trace(System.String,System.Object,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified parameters.
            </summary>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="arg1">First argument to format.</param>
            <param name="arg2">Second argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Trace(System.String,System.Object,System.Object,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified parameters.
            </summary>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="arg1">First argument to format.</param>
            <param name="arg2">Second argument to format.</param>
            <param name="arg3">Third argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Trace(System.IFormatProvider,System.String,System.Boolean)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Trace(System.String,System.Boolean)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Trace(System.IFormatProvider,System.String,System.Char)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Trace(System.String,System.Char)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Trace(System.IFormatProvider,System.String,System.Byte)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Trace(System.String,System.Byte)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Trace(System.IFormatProvider,System.String,System.String)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Trace(System.String,System.String)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Trace(System.IFormatProvider,System.String,System.Int32)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Trace(System.String,System.Int32)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Trace(System.IFormatProvider,System.String,System.Int64)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Trace(System.String,System.Int64)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Trace(System.IFormatProvider,System.String,System.Single)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Trace(System.String,System.Single)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Trace(System.IFormatProvider,System.String,System.Double)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Trace(System.String,System.Double)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Trace(System.IFormatProvider,System.String,System.Decimal)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Trace(System.String,System.Decimal)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Trace(System.IFormatProvider,System.String,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Trace(System.String,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Trace(System.IFormatProvider,System.String,System.SByte)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>s
        </member>
        <member name="M:NLog.ILogger.Trace(System.String,System.SByte)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Trace(System.IFormatProvider,System.String,System.UInt32)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Trace(System.String,System.UInt32)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Trace(System.IFormatProvider,System.String,System.UInt64)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Trace(System.String,System.UInt64)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Debug(System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level.
            </summary>
            <param name="value">A <see langword="object" /> to be written.</param>
        </member>
        <member name="M:NLog.ILogger.Debug(System.IFormatProvider,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="value">A <see langword="object" /> to be written.</param>
        </member>
        <member name="M:NLog.ILogger.Debug(System.String,System.Object,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified parameters.
            </summary>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="arg1">First argument to format.</param>
            <param name="arg2">Second argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Debug(System.String,System.Object,System.Object,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified parameters.
            </summary>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="arg1">First argument to format.</param>
            <param name="arg2">Second argument to format.</param>
            <param name="arg3">Third argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Debug(System.IFormatProvider,System.String,System.Boolean)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Debug(System.String,System.Boolean)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Debug(System.IFormatProvider,System.String,System.Char)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Debug(System.String,System.Char)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Debug(System.IFormatProvider,System.String,System.Byte)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Debug(System.String,System.Byte)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Debug(System.IFormatProvider,System.String,System.String)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Debug(System.String,System.String)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Debug(System.IFormatProvider,System.String,System.Int32)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Debug(System.String,System.Int32)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Debug(System.IFormatProvider,System.String,System.Int64)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Debug(System.String,System.Int64)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Debug(System.IFormatProvider,System.String,System.Single)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Debug(System.String,System.Single)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Debug(System.IFormatProvider,System.String,System.Double)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Debug(System.String,System.Double)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Debug(System.IFormatProvider,System.String,System.Decimal)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Debug(System.String,System.Decimal)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Debug(System.IFormatProvider,System.String,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Debug(System.String,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Debug(System.IFormatProvider,System.String,System.SByte)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Debug(System.String,System.SByte)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Debug(System.IFormatProvider,System.String,System.UInt32)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Debug(System.String,System.UInt32)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Debug(System.IFormatProvider,System.String,System.UInt64)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Debug(System.String,System.UInt64)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Info(System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level.
            </summary>
            <param name="value">A <see langword="object" /> to be written.</param>
        </member>
        <member name="M:NLog.ILogger.Info(System.IFormatProvider,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="value">A <see langword="object" /> to be written.</param>
        </member>
        <member name="M:NLog.ILogger.Info(System.String,System.Object,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified parameters.
            </summary>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="arg1">First argument to format.</param>
            <param name="arg2">Second argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Info(System.String,System.Object,System.Object,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified parameters.
            </summary>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="arg1">First argument to format.</param>
            <param name="arg2">Second argument to format.</param>
            <param name="arg3">Third argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Info(System.IFormatProvider,System.String,System.Boolean)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Info(System.String,System.Boolean)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Info(System.IFormatProvider,System.String,System.Char)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Info(System.String,System.Char)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Info(System.IFormatProvider,System.String,System.Byte)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Info(System.String,System.Byte)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Info(System.IFormatProvider,System.String,System.String)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Info(System.String,System.String)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Info(System.IFormatProvider,System.String,System.Int32)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Info(System.String,System.Int32)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Info(System.IFormatProvider,System.String,System.Int64)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Info(System.String,System.Int64)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Info(System.IFormatProvider,System.String,System.Single)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Info(System.String,System.Single)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Info(System.IFormatProvider,System.String,System.Double)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Info(System.String,System.Double)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Info(System.IFormatProvider,System.String,System.Decimal)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Info(System.String,System.Decimal)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Info(System.IFormatProvider,System.String,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Info(System.String,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Info(System.IFormatProvider,System.String,System.SByte)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Info(System.String,System.SByte)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Info(System.IFormatProvider,System.String,System.UInt32)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Info(System.String,System.UInt32)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Info(System.IFormatProvider,System.String,System.UInt64)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Info(System.String,System.UInt64)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Warn(System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level.
            </summary>
            <param name="value">A <see langword="object" /> to be written.</param>
        </member>
        <member name="M:NLog.ILogger.Warn(System.IFormatProvider,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="value">A <see langword="object" /> to be written.</param>
        </member>
        <member name="M:NLog.ILogger.Warn(System.String,System.Object,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified parameters.
            </summary>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="arg1">First argument to format.</param>
            <param name="arg2">Second argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Warn(System.String,System.Object,System.Object,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified parameters.
            </summary>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="arg1">First argument to format.</param>
            <param name="arg2">Second argument to format.</param>
            <param name="arg3">Third argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Warn(System.IFormatProvider,System.String,System.Boolean)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Warn(System.String,System.Boolean)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Warn(System.IFormatProvider,System.String,System.Char)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Warn(System.String,System.Char)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Warn(System.IFormatProvider,System.String,System.Byte)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Warn(System.String,System.Byte)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Warn(System.IFormatProvider,System.String,System.String)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Warn(System.String,System.String)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Warn(System.IFormatProvider,System.String,System.Int32)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Warn(System.String,System.Int32)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Warn(System.IFormatProvider,System.String,System.Int64)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Warn(System.String,System.Int64)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Warn(System.IFormatProvider,System.String,System.Single)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Warn(System.String,System.Single)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Warn(System.IFormatProvider,System.String,System.Double)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Warn(System.String,System.Double)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Warn(System.IFormatProvider,System.String,System.Decimal)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Warn(System.String,System.Decimal)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Warn(System.IFormatProvider,System.String,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Warn(System.String,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Warn(System.IFormatProvider,System.String,System.SByte)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Warn(System.String,System.SByte)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Warn(System.IFormatProvider,System.String,System.UInt32)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Warn(System.String,System.UInt32)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Warn(System.IFormatProvider,System.String,System.UInt64)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Warn(System.String,System.UInt64)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Error(System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level.
            </summary>
            <param name="value">A <see langword="object" /> to be written.</param>
        </member>
        <member name="M:NLog.ILogger.Error(System.IFormatProvider,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="value">A <see langword="object" /> to be written.</param>
        </member>
        <member name="M:NLog.ILogger.Error(System.String,System.Object,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified parameters.
            </summary>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="arg1">First argument to format.</param>
            <param name="arg2">Second argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Error(System.String,System.Object,System.Object,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified parameters.
            </summary>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="arg1">First argument to format.</param>
            <param name="arg2">Second argument to format.</param>
            <param name="arg3">Third argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Error(System.IFormatProvider,System.String,System.Boolean)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Error(System.String,System.Boolean)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Error(System.IFormatProvider,System.String,System.Char)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Error(System.String,System.Char)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Error(System.IFormatProvider,System.String,System.Byte)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Error(System.String,System.Byte)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Error(System.IFormatProvider,System.String,System.String)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Error(System.String,System.String)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Error(System.IFormatProvider,System.String,System.Int32)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Error(System.String,System.Int32)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Error(System.IFormatProvider,System.String,System.Int64)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Error(System.String,System.Int64)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Error(System.IFormatProvider,System.String,System.Single)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Error(System.String,System.Single)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Error(System.IFormatProvider,System.String,System.Double)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Error(System.String,System.Double)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Error(System.IFormatProvider,System.String,System.Decimal)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Error(System.String,System.Decimal)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Error(System.IFormatProvider,System.String,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Error(System.String,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Error(System.IFormatProvider,System.String,System.SByte)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Error(System.String,System.SByte)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Error(System.IFormatProvider,System.String,System.UInt32)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Error(System.String,System.UInt32)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Error(System.IFormatProvider,System.String,System.UInt64)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Error(System.String,System.UInt64)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Fatal(System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level.
            </summary>
            <param name="value">A <see langword="object" /> to be written.</param>
        </member>
        <member name="M:NLog.ILogger.Fatal(System.IFormatProvider,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="value">A <see langword="object" /> to be written.</param>
        </member>
        <member name="M:NLog.ILogger.Fatal(System.String,System.Object,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified parameters.
            </summary>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="arg1">First argument to format.</param>
            <param name="arg2">Second argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Fatal(System.String,System.Object,System.Object,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified parameters.
            </summary>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="arg1">First argument to format.</param>
            <param name="arg2">Second argument to format.</param>
            <param name="arg3">Third argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Fatal(System.IFormatProvider,System.String,System.Boolean)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Fatal(System.String,System.Boolean)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Fatal(System.IFormatProvider,System.String,System.Char)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Fatal(System.String,System.Char)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Fatal(System.IFormatProvider,System.String,System.Byte)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Fatal(System.String,System.Byte)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Fatal(System.IFormatProvider,System.String,System.String)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Fatal(System.String,System.String)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Fatal(System.IFormatProvider,System.String,System.Int32)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Fatal(System.String,System.Int32)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Fatal(System.IFormatProvider,System.String,System.Int64)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Fatal(System.String,System.Int64)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Fatal(System.IFormatProvider,System.String,System.Single)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Fatal(System.String,System.Single)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Fatal(System.IFormatProvider,System.String,System.Double)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Fatal(System.String,System.Double)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Fatal(System.IFormatProvider,System.String,System.Decimal)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Fatal(System.String,System.Decimal)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Fatal(System.IFormatProvider,System.String,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Fatal(System.String,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Fatal(System.IFormatProvider,System.String,System.SByte)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Fatal(System.String,System.SByte)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Fatal(System.IFormatProvider,System.String,System.UInt32)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Fatal(System.String,System.UInt32)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Fatal(System.IFormatProvider,System.String,System.UInt64)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Fatal(System.String,System.UInt64)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="P:NLog.ILogger.IsTraceEnabled">
            <summary>
            Gets a value indicating whether logging is enabled for the <c>Trace</c> level.
            </summary>
            <returns>A value of <see langword="true" /> if logging is enabled for the <c>Trace</c> level, otherwise it returns <see langword="false" />.</returns>
        </member>
        <member name="P:NLog.ILogger.IsDebugEnabled">
            <summary>
            Gets a value indicating whether logging is enabled for the <c>Debug</c> level.
            </summary>
            <returns>A value of <see langword="true" /> if logging is enabled for the <c>Debug</c> level, otherwise it returns <see langword="false" />.</returns>
        </member>
        <member name="P:NLog.ILogger.IsInfoEnabled">
            <summary>
            Gets a value indicating whether logging is enabled for the <c>Info</c> level.
            </summary>
            <returns>A value of <see langword="true" /> if logging is enabled for the <c>Info</c> level, otherwise it returns <see langword="false" />.</returns>
        </member>
        <member name="P:NLog.ILogger.IsWarnEnabled">
            <summary>
            Gets a value indicating whether logging is enabled for the <c>Warn</c> level.
            </summary>
            <returns>A value of <see langword="true" /> if logging is enabled for the <c>Warn</c> level, otherwise it returns <see langword="false" />.</returns>
        </member>
        <member name="P:NLog.ILogger.IsErrorEnabled">
            <summary>
            Gets a value indicating whether logging is enabled for the <c>Error</c> level.
            </summary>
            <returns>A value of <see langword="true" /> if logging is enabled for the <c>Error</c> level, otherwise it returns <see langword="false" />.</returns>
        </member>
        <member name="P:NLog.ILogger.IsFatalEnabled">
            <summary>
            Gets a value indicating whether logging is enabled for the <c>Fatal</c> level.
            </summary>
            <returns>A value of <see langword="true" /> if logging is enabled for the <c>Fatal</c> level, otherwise it returns <see langword="false" />.</returns>
        </member>
        <member name="M:NLog.ILogger.Trace``1(``0)">
            <overloads>
            Writes the diagnostic message at the <c>Trace</c> level using the specified format provider and format parameters.
            </overloads>
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level.
            </summary>
            <typeparam name="T">Type of the value.</typeparam>
            <param name="value">The value to be written.</param>
        </member>
        <member name="M:NLog.ILogger.Trace``1(System.IFormatProvider,``0)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level.
            </summary>
            <typeparam name="T">Type of the value.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="value">The value to be written.</param>
        </member>
        <member name="M:NLog.ILogger.Trace(NLog.LogMessageGenerator)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level.
            </summary>
            <param name="messageFunc">A function returning message to be written. Function is not evaluated if logging is not enabled.</param>
        </member>
        <member name="M:NLog.ILogger.TraceException(System.String,System.Exception)">
            <summary>
            Obsolete and replaced by <see cref="M:NLog.ILogger.Trace(System.Exception,System.String)"/> - Writes the diagnostic message and exception at the <c>Trace</c> level.
            </summary>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
            <remarks>This method was marked as obsolete before NLog 4.3.11 and it may be removed in a future release.</remarks>
        </member>
        <member name="M:NLog.ILogger.Trace(System.Exception,System.String)">
            <summary>
            Writes the diagnostic message and exception at the <c>Trace</c> level.
            </summary>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
        </member>
        <member name="M:NLog.ILogger.Trace(System.Exception,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message and exception at the <c>Trace</c> level.
            </summary>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.ILogger.Trace(System.Exception,System.IFormatProvider,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message and exception at the <c>Trace</c> level.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.ILogger.Trace(System.IFormatProvider,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified parameters and formatting them with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.ILogger.Trace(System.String)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level.
            </summary>
            <param name="message">Log message.</param>
        </member>
        <member name="M:NLog.ILogger.Trace(System.String,System.Object[])">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified parameters.
            </summary>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.ILogger.Trace(System.String,System.Exception)">
            <summary>
            Obsolete and replaced by <see cref="M:NLog.ILogger.Trace(System.Exception,System.String)"/> - Writes the diagnostic message and exception at the <c>Trace</c> level.
            </summary>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
            <remarks>This method was marked as obsolete before NLog 4.3.11 and it may be removed in a future release.</remarks>
        </member>
        <member name="M:NLog.ILogger.Trace``1(System.IFormatProvider,System.String,``0)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified parameter and formatting it with the supplied format provider.
            </summary>
            <typeparam name="TArgument">The type of the argument.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Trace``1(System.String,``0)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified parameter.
            </summary>
            <typeparam name="TArgument">The type of the argument.</typeparam>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Trace``2(System.IFormatProvider,System.String,``0,``1)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified arguments formatting it with the supplied format provider.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Trace``2(System.String,``0,``1)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified parameters.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Trace``3(System.IFormatProvider,System.String,``0,``1,``2)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified arguments formatting it with the supplied format provider.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <typeparam name="TArgument3">The type of the third argument.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
            <param name="argument3">The third argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Trace``3(System.String,``0,``1,``2)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified parameters.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <typeparam name="TArgument3">The type of the third argument.</typeparam>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
            <param name="argument3">The third argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Debug``1(``0)">
            <overloads>
            Writes the diagnostic message at the <c>Debug</c> level using the specified format provider and format parameters.
            </overloads>
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level.
            </summary>
            <typeparam name="T">Type of the value.</typeparam>
            <param name="value">The value to be written.</param>
        </member>
        <member name="M:NLog.ILogger.Debug``1(System.IFormatProvider,``0)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level.
            </summary>
            <typeparam name="T">Type of the value.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="value">The value to be written.</param>
        </member>
        <member name="M:NLog.ILogger.Debug(NLog.LogMessageGenerator)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level.
            </summary>
            <param name="messageFunc">A function returning message to be written. Function is not evaluated if logging is not enabled.</param>
        </member>
        <member name="M:NLog.ILogger.Debug(System.Exception,System.String)">
            <summary>
            Writes the diagnostic message and exception at the <c>Debug</c> level.
            </summary>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
        </member>
        <member name="M:NLog.ILogger.Debug(System.Exception,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message and exception at the <c>Debug</c> level.
            </summary>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.ILogger.Debug(System.Exception,System.IFormatProvider,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message and exception at the <c>Debug</c> level.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.ILogger.Debug(System.IFormatProvider,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified parameters and formatting them with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.ILogger.Debug(System.String)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level.
            </summary>
            <param name="message">Log message.</param>
        </member>
        <member name="M:NLog.ILogger.Debug(System.String,System.Object[])">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified parameters.
            </summary>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.ILogger.Debug``1(System.IFormatProvider,System.String,``0)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified parameter and formatting it with the supplied format provider.
            </summary>
            <typeparam name="TArgument">The type of the argument.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Debug``1(System.String,``0)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified parameter.
            </summary>
            <typeparam name="TArgument">The type of the argument.</typeparam>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Debug``2(System.IFormatProvider,System.String,``0,``1)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified arguments formatting it with the supplied format provider.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Debug``2(System.String,``0,``1)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified parameters.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Debug``3(System.IFormatProvider,System.String,``0,``1,``2)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified arguments formatting it with the supplied format provider.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <typeparam name="TArgument3">The type of the third argument.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
            <param name="argument3">The third argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Debug``3(System.String,``0,``1,``2)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified parameters.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <typeparam name="TArgument3">The type of the third argument.</typeparam>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
            <param name="argument3">The third argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Debug(System.String,System.Exception)">
            <summary>
            Obsolete and replaced by <see cref="M:NLog.ILogger.Debug(System.Exception,System.String)"/> - Writes the diagnostic message and exception at the <c>Debug</c> level.
            </summary>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
            <remarks>This method was marked as obsolete before NLog 4.3.11 and it may be removed in a future release.</remarks>
        </member>
        <member name="M:NLog.ILogger.DebugException(System.String,System.Exception)">
            <summary>
            Obsolete and replaced by <see cref="M:NLog.ILogger.Debug(System.Exception,System.String)"/> - Writes the diagnostic message and exception at the <c>Debug</c> level.
            </summary>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
            <remarks>This method was marked as obsolete before NLog 4.3.11 and it may be removed in a future release.</remarks>
        </member>
        <member name="M:NLog.ILogger.Info``1(``0)">
            <overloads>
            Writes the diagnostic message at the <c>Info</c> level using the specified format provider and format parameters.
            </overloads>
            <summary>
            Writes the diagnostic message at the <c>Info</c> level.
            </summary>
            <typeparam name="T">Type of the value.</typeparam>
            <param name="value">The value to be written.</param>
        </member>
        <member name="M:NLog.ILogger.Info``1(System.IFormatProvider,``0)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level.
            </summary>
            <typeparam name="T">Type of the value.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="value">The value to be written.</param>
        </member>
        <member name="M:NLog.ILogger.Info(NLog.LogMessageGenerator)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level.
            </summary>
            <param name="messageFunc">A function returning message to be written. Function is not evaluated if logging is not enabled.</param>
        </member>
        <member name="M:NLog.ILogger.Info(System.Exception,System.String)">
            <summary>
            Writes the diagnostic message and exception at the <c>Info</c> level.
            </summary>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
        </member>
        <member name="M:NLog.ILogger.Info(System.Exception,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message and exception at the <c>Info</c> level.
            </summary>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.ILogger.Info(System.Exception,System.IFormatProvider,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message and exception at the <c>Info</c> level.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.ILogger.Info(System.IFormatProvider,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified parameters and formatting them with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.ILogger.Info(System.String)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level.
            </summary>
            <param name="message">Log message.</param>
        </member>
        <member name="M:NLog.ILogger.Info(System.String,System.Object[])">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified parameters.
            </summary>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.ILogger.Info``1(System.IFormatProvider,System.String,``0)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified parameter and formatting it with the supplied format provider.
            </summary>
            <typeparam name="TArgument">The type of the argument.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Info``1(System.String,``0)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified parameter.
            </summary>
            <typeparam name="TArgument">The type of the argument.</typeparam>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Info``2(System.IFormatProvider,System.String,``0,``1)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified arguments formatting it with the supplied format provider.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Info``2(System.String,``0,``1)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified parameters.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Info``3(System.IFormatProvider,System.String,``0,``1,``2)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified arguments formatting it with the supplied format provider.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <typeparam name="TArgument3">The type of the third argument.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
            <param name="argument3">The third argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Info``3(System.String,``0,``1,``2)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified parameters.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <typeparam name="TArgument3">The type of the third argument.</typeparam>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
            <param name="argument3">The third argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Info(System.String,System.Exception)">
            <summary>
            Obsolete and replaced by <see cref="M:NLog.ILogger.Info(System.Exception,System.String)"/> - Writes the diagnostic message and exception at the <c>Info</c> level.
            </summary>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
            <remarks>This method was marked as obsolete before NLog 4.3.11 and it may be removed in a future release.</remarks>
        </member>
        <member name="M:NLog.ILogger.InfoException(System.String,System.Exception)">
            <summary>
            Obsolete and replaced by <see cref="M:NLog.ILogger.Info(System.Exception,System.String)"/> - Writes the diagnostic message and exception at the <c>Info</c> level.
            </summary>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
            <remarks>This method was marked as obsolete before NLog 4.3.11 and it may be removed in a future release.</remarks>
        </member>
        <member name="M:NLog.ILogger.Warn``1(``0)">
            <overloads>
            Writes the diagnostic message at the <c>Warn</c> level using the specified format provider and format parameters.
            </overloads>
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level.
            </summary>
            <typeparam name="T">Type of the value.</typeparam>
            <param name="value">The value to be written.</param>
        </member>
        <member name="M:NLog.ILogger.Warn``1(System.IFormatProvider,``0)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level.
            </summary>
            <typeparam name="T">Type of the value.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="value">The value to be written.</param>
        </member>
        <member name="M:NLog.ILogger.Warn(NLog.LogMessageGenerator)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level.
            </summary>
            <param name="messageFunc">A function returning message to be written. Function is not evaluated if logging is not enabled.</param>
        </member>
        <member name="M:NLog.ILogger.Warn(System.Exception,System.String)">
            <summary>
            Writes the diagnostic message and exception at the <c>Warn</c> level.
            </summary>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
        </member>
        <member name="M:NLog.ILogger.Warn(System.Exception,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message and exception at the <c>Warn</c> level.
            </summary>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.ILogger.Warn(System.Exception,System.IFormatProvider,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message and exception at the <c>Warn</c> level.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.ILogger.Warn(System.IFormatProvider,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified parameters and formatting them with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.ILogger.Warn(System.String)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level.
            </summary>
            <param name="message">Log message.</param>
        </member>
        <member name="M:NLog.ILogger.Warn(System.String,System.Object[])">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified parameters.
            </summary>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.ILogger.Warn``1(System.IFormatProvider,System.String,``0)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified parameter and formatting it with the supplied format provider.
            </summary>
            <typeparam name="TArgument">The type of the argument.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Warn``1(System.String,``0)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified parameter.
            </summary>
            <typeparam name="TArgument">The type of the argument.</typeparam>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Warn``2(System.IFormatProvider,System.String,``0,``1)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified arguments formatting it with the supplied format provider.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Warn``2(System.String,``0,``1)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified parameters.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Warn``3(System.IFormatProvider,System.String,``0,``1,``2)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified arguments formatting it with the supplied format provider.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <typeparam name="TArgument3">The type of the third argument.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
            <param name="argument3">The third argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Warn``3(System.String,``0,``1,``2)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified parameters.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <typeparam name="TArgument3">The type of the third argument.</typeparam>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
            <param name="argument3">The third argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Warn(System.String,System.Exception)">
            <summary>
            Obsolete and replaced by <see cref="M:NLog.ILogger.Warn(System.Exception,System.String)"/> - Writes the diagnostic message and exception at the <c>Warn</c> level.
            </summary>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
            <remarks>This method was marked as obsolete before NLog 4.3.11 and it may be removed in a future release.</remarks>
        </member>
        <member name="M:NLog.ILogger.WarnException(System.String,System.Exception)">
            <summary>
            Obsolete and replaced by <see cref="M:NLog.ILogger.Warn(System.Exception,System.String)"/> - Writes the diagnostic message and exception at the <c>Warn</c> level.
            </summary>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
            <remarks>This method was marked as obsolete before NLog 4.3.11 and it may be removed in a future release.</remarks>
        </member>
        <member name="M:NLog.ILogger.Error``1(``0)">
            <overloads>
            Writes the diagnostic message at the <c>Error</c> level using the specified format provider and format parameters.
            </overloads>
            <summary>
            Writes the diagnostic message at the <c>Error</c> level.
            </summary>
            <typeparam name="T">Type of the value.</typeparam>
            <param name="value">The value to be written.</param>
        </member>
        <member name="M:NLog.ILogger.Error``1(System.IFormatProvider,``0)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level.
            </summary>
            <typeparam name="T">Type of the value.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="value">The value to be written.</param>
        </member>
        <member name="M:NLog.ILogger.Error(NLog.LogMessageGenerator)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level.
            </summary>
            <param name="messageFunc">A function returning message to be written. Function is not evaluated if logging is not enabled.</param>
        </member>
        <member name="M:NLog.ILogger.Error(System.Exception,System.String)">
            <summary>
            Writes the diagnostic message and exception at the <c>Error</c> level.
            </summary>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
        </member>
        <member name="M:NLog.ILogger.Error(System.Exception,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message and exception at the <c>Error</c> level.
            </summary>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.ILogger.Error(System.Exception,System.IFormatProvider,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message and exception at the <c>Error</c> level.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.ILogger.Error(System.IFormatProvider,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified parameters and formatting them with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.ILogger.Error(System.String)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level.
            </summary>
            <param name="message">Log message.</param>
        </member>
        <member name="M:NLog.ILogger.Error(System.String,System.Object[])">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified parameters.
            </summary>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.ILogger.Error``1(System.IFormatProvider,System.String,``0)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified parameter and formatting it with the supplied format provider.
            </summary>
            <typeparam name="TArgument">The type of the argument.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Error``1(System.String,``0)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified parameter.
            </summary>
            <typeparam name="TArgument">The type of the argument.</typeparam>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Error``2(System.IFormatProvider,System.String,``0,``1)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified arguments formatting it with the supplied format provider.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Error``2(System.String,``0,``1)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified parameters.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Error``3(System.IFormatProvider,System.String,``0,``1,``2)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified arguments formatting it with the supplied format provider.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <typeparam name="TArgument3">The type of the third argument.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
            <param name="argument3">The third argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Error``3(System.String,``0,``1,``2)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified parameters.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <typeparam name="TArgument3">The type of the third argument.</typeparam>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
            <param name="argument3">The third argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Error(System.String,System.Exception)">
            <summary>
            Obsolete and replaced by <see cref="M:NLog.ILogger.Error(System.Exception,System.String)"/> - Writes the diagnostic message and exception at the <c>Error</c> level.
            </summary>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
            <remarks>This method was marked as obsolete before NLog 4.3.11 and it may be removed in a future release.</remarks>
        </member>
        <member name="M:NLog.ILogger.ErrorException(System.String,System.Exception)">
            <summary>
            Obsolete and replaced by <see cref="M:NLog.ILogger.Error(System.Exception,System.String)"/> - Writes the diagnostic message and exception at the <c>Error</c> level.
            </summary>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
            <remarks>This method was marked as obsolete before NLog 4.3.11 and it may be removed in a future release.</remarks>
        </member>
        <member name="M:NLog.ILogger.Fatal``1(``0)">
            <overloads>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified format provider and format parameters.
            </overloads>
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level.
            </summary>
            <typeparam name="T">Type of the value.</typeparam>
            <param name="value">The value to be written.</param>
        </member>
        <member name="M:NLog.ILogger.Fatal``1(System.IFormatProvider,``0)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level.
            </summary>
            <typeparam name="T">Type of the value.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="value">The value to be written.</param>
        </member>
        <member name="M:NLog.ILogger.Fatal(NLog.LogMessageGenerator)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level.
            </summary>
            <param name="messageFunc">A function returning message to be written. Function is not evaluated if logging is not enabled.</param>
        </member>
        <member name="M:NLog.ILogger.Fatal(System.Exception,System.String)">
            <summary>
            Writes the diagnostic message and exception at the <c>Fatal</c> level.
            </summary>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
        </member>
        <member name="M:NLog.ILogger.Fatal(System.Exception,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message and exception at the <c>Fatal</c> level.
            </summary>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.ILogger.Fatal(System.Exception,System.IFormatProvider,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message and exception at the <c>Fatal</c> level.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.ILogger.Fatal(System.IFormatProvider,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified parameters and formatting them with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.ILogger.Fatal(System.String)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level.
            </summary>
            <param name="message">Log message.</param>
        </member>
        <member name="M:NLog.ILogger.Fatal(System.String,System.Object[])">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified parameters.
            </summary>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.ILogger.Fatal``1(System.IFormatProvider,System.String,``0)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified parameter and formatting it with the supplied format provider.
            </summary>
            <typeparam name="TArgument">The type of the argument.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Fatal``1(System.String,``0)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified parameter.
            </summary>
            <typeparam name="TArgument">The type of the argument.</typeparam>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Fatal``2(System.IFormatProvider,System.String,``0,``1)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified arguments formatting it with the supplied format provider.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Fatal``2(System.String,``0,``1)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified parameters.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Fatal``3(System.IFormatProvider,System.String,``0,``1,``2)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified arguments formatting it with the supplied format provider.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <typeparam name="TArgument3">The type of the third argument.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
            <param name="argument3">The third argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Fatal``3(System.String,``0,``1,``2)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified parameters.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <typeparam name="TArgument3">The type of the third argument.</typeparam>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
            <param name="argument3">The third argument to format.</param>
        </member>
        <member name="M:NLog.ILogger.Fatal(System.String,System.Exception)">
            <summary>
            Obsolete and replaced by <see cref="M:NLog.ILogger.Fatal(System.Exception,System.String)"/> - Writes the diagnostic message and exception at the <c>Fatal</c> level.
            </summary>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
            <remarks>This method was marked as obsolete before NLog 4.3.11 and it may be removed in a future release.</remarks>
        </member>
        <member name="M:NLog.ILogger.FatalException(System.String,System.Exception)">
            <summary>
            Obsolete and replaced by <see cref="M:NLog.ILogger.Fatal(System.Exception,System.String)"/> - Writes the diagnostic message and exception at the <c>Fatal</c> level.
            </summary>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
            <remarks>This method was marked as obsolete before NLog 4.3.11 and it may be removed in a future release.</remarks>
        </member>
        <member name="T:NLog.ILoggerBase">
            <content>
            Auto-generated Logger members for binary compatibility with NLog 1.0.
            </content>
             <summary>
             Obsolete and replaced by <see cref="T:NLog.ILogger"/> with NLog v5.3.
            
             Logger with only generic methods (passing 'LogLevel' to methods) and core properties.
             </summary>
        </member>
        <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.Object)">
            <summary>
            Writes the diagnostic message at the specified level.
            </summary>
            <param name="level">The log level.</param>
            <param name="value">A <see langword="object" /> to be written.</param>
        </member>
        <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.IFormatProvider,System.Object)">
            <summary>
            Writes the diagnostic message at the specified level.
            </summary>
            <param name="level">The log level.</param>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="value">A <see langword="object" /> to be written.</param>
        </member>
        <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.String,System.Object,System.Object)">
            <summary>
            Writes the diagnostic message at the specified level using the specified parameters.
            </summary>
            <param name="level">The log level.</param>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="arg1">First argument to format.</param>
            <param name="arg2">Second argument to format.</param>
        </member>
        <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.String,System.Object,System.Object,System.Object)">
            <summary>
            Writes the diagnostic message at the specified level using the specified parameters.
            </summary>
            <param name="level">The log level.</param>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="arg1">First argument to format.</param>
            <param name="arg2">Second argument to format.</param>
            <param name="arg3">Third argument to format.</param>
        </member>
        <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.IFormatProvider,System.String,System.Boolean)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="level">The log level.</param>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.String,System.Boolean)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter.
            </summary>
            <param name="level">The log level.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.IFormatProvider,System.String,System.Char)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="level">The log level.</param>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.String,System.Char)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter.
            </summary>
            <param name="level">The log level.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.IFormatProvider,System.String,System.Byte)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="level">The log level.</param>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.String,System.Byte)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter.
            </summary>
            <param name="level">The log level.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.IFormatProvider,System.String,System.String)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="level">The log level.</param>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.String,System.String)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter.
            </summary>
            <param name="level">The log level.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.IFormatProvider,System.String,System.Int32)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="level">The log level.</param>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.String,System.Int32)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter.
            </summary>
            <param name="level">The log level.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.IFormatProvider,System.String,System.Int64)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="level">The log level.</param>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.String,System.Int64)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter.
            </summary>
            <param name="level">The log level.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.IFormatProvider,System.String,System.Single)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="level">The log level.</param>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.String,System.Single)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter.
            </summary>
            <param name="level">The log level.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.IFormatProvider,System.String,System.Double)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="level">The log level.</param>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.String,System.Double)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter.
            </summary>
            <param name="level">The log level.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.IFormatProvider,System.String,System.Decimal)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="level">The log level.</param>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.String,System.Decimal)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter.
            </summary>
            <param name="level">The log level.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.IFormatProvider,System.String,System.Object)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="level">The log level.</param>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.String,System.Object)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter.
            </summary>
            <param name="level">The log level.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.IFormatProvider,System.String,System.SByte)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="level">The log level.</param>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.String,System.SByte)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter.
            </summary>
            <param name="level">The log level.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.IFormatProvider,System.String,System.UInt32)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="level">The log level.</param>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.String,System.UInt32)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter.
            </summary>
            <param name="level">The log level.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.IFormatProvider,System.String,System.UInt64)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="level">The log level.</param>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.String,System.UInt64)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter.
            </summary>
            <param name="level">The log level.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="E:NLog.ILoggerBase.LoggerReconfigured">
            <summary>
            Obsolete on the ILogger-interface, instead use <see cref="E:NLog.Logger.LoggerReconfigured"/> with NLog v5.3.
            Occurs when logger configuration changes.
            </summary>
        </member>
        <member name="P:NLog.ILoggerBase.Name">
            <summary>
            Gets the name of the logger.
            </summary>
        </member>
        <member name="P:NLog.ILoggerBase.Factory">
            <summary>
            Obsolete on the ILogger-interface, instead use <see cref="P:NLog.Logger.Factory"/> with NLog v5.3.
            Gets the factory that created this logger.
            </summary>
        </member>
        <member name="M:NLog.ILoggerBase.IsEnabled(NLog.LogLevel)">
            <summary>
            Gets a value indicating whether logging is enabled for the specified level.
            </summary>
            <param name="level">Log level to be checked.</param>
            <returns>A value of <see langword="true" /> if logging is enabled for the specified level, otherwise it returns <see langword="false" />.</returns>
        </member>
        <member name="M:NLog.ILoggerBase.Log(NLog.LogEventInfo)">
            <summary>
            Writes the specified diagnostic message.
            </summary>
            <param name="logEvent">Log event.</param>
        </member>
        <member name="M:NLog.ILoggerBase.Log(System.Type,NLog.LogEventInfo)">
            <summary>
            Writes the specified diagnostic message.
            </summary>
            <param name="wrapperType">Type of custom Logger wrapper.</param>
            <param name="logEvent">Log event.</param>
        </member>
        <member name="M:NLog.ILoggerBase.Log``1(NLog.LogLevel,``0)">
            <overloads>
            Writes the diagnostic message at the specified level using the specified format provider and format parameters.
            </overloads>
            <summary>
            Writes the diagnostic message at the specified level.
            </summary>
            <typeparam name="T">Type of the value.</typeparam>
            <param name="level">The log level.</param>
            <param name="value">The value to be written.</param>
        </member>
        <member name="M:NLog.ILoggerBase.Log``1(NLog.LogLevel,System.IFormatProvider,``0)">
            <summary>
            Writes the diagnostic message at the specified level.
            </summary>
            <typeparam name="T">Type of the value.</typeparam>
            <param name="level">The log level.</param>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="value">The value to be written.</param>
        </member>
        <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,NLog.LogMessageGenerator)">
            <summary>
            Writes the diagnostic message at the specified level.
            </summary>
            <param name="level">The log level.</param>
            <param name="messageFunc">A function returning message to be written. Function is not evaluated if logging is not enabled.</param>
        </member>
        <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.Exception,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message and exception at the specified level.
            </summary>
            <param name="level">The log level.</param>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="args">Arguments to format.</param>
            <param name="exception">An exception to be logged.</param>
        </member>
        <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.Exception,System.IFormatProvider,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message and exception at the specified level.
            </summary>
            <param name="level">The log level.</param>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="args">Arguments to format.</param>
            <param name="exception">An exception to be logged.</param>
        </member>
        <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.IFormatProvider,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message at the specified level using the specified parameters and formatting them with the supplied format provider.
            </summary>
            <param name="level">The log level.</param>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.String)">
            <summary>
            Writes the diagnostic message at the specified level.
            </summary>
            <param name="level">The log level.</param>
            <param name="message">Log message.</param>
        </member>
        <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message at the specified level using the specified parameters.
            </summary>
            <param name="level">The log level.</param>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.ILoggerBase.Log``1(NLog.LogLevel,System.IFormatProvider,System.String,``0)">
            <summary>
            Writes the diagnostic message at the specified level using the specified parameter and formatting it with the supplied format provider.
            </summary>
            <typeparam name="TArgument">The type of the argument.</typeparam>
            <param name="level">The log level.</param>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILoggerBase.Log``1(NLog.LogLevel,System.String,``0)">
            <summary>
            Writes the diagnostic message at the specified level using the specified parameter.
            </summary>
            <typeparam name="TArgument">The type of the argument.</typeparam>
            <param name="level">The log level.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILoggerBase.Log``2(NLog.LogLevel,System.IFormatProvider,System.String,``0,``1)">
            <summary>
            Writes the diagnostic message at the specified level using the specified arguments formatting it with the supplied format provider.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <param name="level">The log level.</param>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
        </member>
        <member name="M:NLog.ILoggerBase.Log``2(NLog.LogLevel,System.String,``0,``1)">
            <summary>
            Writes the diagnostic message at the specified level using the specified parameters.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <param name="level">The log level.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
        </member>
        <member name="M:NLog.ILoggerBase.Log``3(NLog.LogLevel,System.IFormatProvider,System.String,``0,``1,``2)">
            <summary>
            Writes the diagnostic message at the specified level using the specified arguments formatting it with the supplied format provider.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <typeparam name="TArgument3">The type of the third argument.</typeparam>
            <param name="level">The log level.</param>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
            <param name="argument3">The third argument to format.</param>
        </member>
        <member name="M:NLog.ILoggerBase.Log``3(NLog.LogLevel,System.String,``0,``1,``2)">
            <summary>
            Writes the diagnostic message at the specified level using the specified parameters.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <typeparam name="TArgument3">The type of the third argument.</typeparam>
            <param name="level">The log level.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
            <param name="argument3">The third argument to format.</param>
        </member>
        <member name="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.String,System.Exception)">
            <summary>
            Obsolete and replaced by <see cref="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.Exception,System.String,System.Object[])"/> - Writes the diagnostic message and exception at the specified level.
            </summary>
            <param name="level">The log level.</param>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
            <remarks>This method was marked as obsolete before NLog 4.3.11 and it may be removed in a future release.</remarks>
        </member>
        <member name="M:NLog.ILoggerBase.LogException(NLog.LogLevel,System.String,System.Exception)">
            <summary>
            Obsolete and replaced by <see cref="M:NLog.ILoggerBase.Log(NLog.LogLevel,System.Exception,System.String,System.Object[])"/> - Writes the diagnostic message and exception at the specified level.
            </summary>
            <param name="level">The log level.</param>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
            <remarks>This method was marked as obsolete before NLog 4.3.11 and it may be removed in a future release.</remarks>
        </member>
        <member name="T:NLog.ILoggerExtensions">
            <summary>
            Extensions for NLog <see cref="T:NLog.ILogger"/>.
            </summary>
        </member>
        <member name="M:NLog.ILoggerExtensions.ForLogEvent(NLog.ILogger,NLog.LogLevel)">
            <summary>
            Starts building a log event with the specified <see cref="T:NLog.LogLevel"/>.
            </summary>
            <param name="logger">The logger to write the log event to.</param>
            <param name="logLevel">The log level. When not</param>
            <returns><see cref="T:NLog.LogEventBuilder"/> for chaining calls.</returns>
        </member>
        <member name="M:NLog.ILoggerExtensions.ForTraceEvent(NLog.ILogger)">
            <summary>
            Starts building a log event at the <c>Trace</c> level.
            </summary>
            <param name="logger">The logger to write the log event to.</param>
            <returns><see cref="T:NLog.LogEventBuilder"/> for chaining calls.</returns>
        </member>
        <member name="M:NLog.ILoggerExtensions.ForDebugEvent(NLog.ILogger)">
            <summary>
            Starts building a log event at the <c>Debug</c> level.
            </summary>
            <param name="logger">The logger to write the log event to.</param>
            <returns><see cref="T:NLog.LogEventBuilder"/> for chaining calls.</returns>
        </member>
        <member name="M:NLog.ILoggerExtensions.ForInfoEvent(NLog.ILogger)">
            <summary>
            Starts building a log event at the <c>Info</c> level.
            </summary>
            <param name="logger">The logger to write the log event to.</param>
            <returns><see cref="T:NLog.LogEventBuilder"/> for chaining calls.</returns>
        </member>
        <member name="M:NLog.ILoggerExtensions.ForWarnEvent(NLog.ILogger)">
            <summary>
            Starts building a log event at the <c>Warn</c> level.
            </summary>
            <param name="logger">The logger to write the log event to.</param>
            <returns><see cref="T:NLog.LogEventBuilder"/> for chaining calls.</returns>
        </member>
        <member name="M:NLog.ILoggerExtensions.ForErrorEvent(NLog.ILogger)">
            <summary>
            Starts building a log event at the <c>Error</c> level.
            </summary>
            <param name="logger">The logger to write the log event to.</param>
            <returns><see cref="T:NLog.LogEventBuilder"/> for chaining calls.</returns>
        </member>
        <member name="M:NLog.ILoggerExtensions.ForFatalEvent(NLog.ILogger)">
            <summary>
            Starts building a log event at the <c>Fatal</c> level.
            </summary>
            <param name="logger">The logger to write the log event to.</param>
            <returns><see cref="T:NLog.LogEventBuilder"/> for chaining calls.</returns>
        </member>
        <member name="M:NLog.ILoggerExtensions.ForExceptionEvent(NLog.ILogger,System.Exception,NLog.LogLevel)">
            <summary>
            Starts building a log event at the <c>Exception</c> level.
            </summary>
            <param name="logger">The logger to write the log event to.</param>
            <param name="exception">The exception information of the logging event.</param>
            <param name="logLevel">The <see cref="T:NLog.LogLevel"/> for the log event. Defaults to <see cref="F:NLog.LogLevel.Error"/> when not specified.</param>
            <returns><see cref="T:NLog.LogEventBuilder"/> for chaining calls.</returns>
        </member>
        <member name="M:NLog.ILoggerExtensions.ConditionalDebug``1(NLog.ILogger,``0)">
            <overloads>
            Writes the diagnostic message at the <c>Debug</c> level using the specified format provider and format parameters.
            </overloads>
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <typeparam name="T">Type of the value.</typeparam>
            <param name="logger">A logger implementation that will handle the message.</param>
            <param name="value">The value to be written.</param>
        </member>
        <member name="M:NLog.ILoggerExtensions.ConditionalDebug``1(NLog.ILogger,System.IFormatProvider,``0)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <typeparam name="T">Type of the value.</typeparam>
            <param name="logger">A logger implementation that will handle the message.</param>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="value">The value to be written.</param>
        </member>
        <member name="M:NLog.ILoggerExtensions.ConditionalDebug(NLog.ILogger,NLog.LogMessageGenerator)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="logger">A logger implementation that will handle the message.</param>
            <param name="messageFunc">A function returning message to be written. Function is not evaluated if logging is not enabled.</param>
        </member>
        <member name="M:NLog.ILoggerExtensions.ConditionalDebug(NLog.ILogger,System.Exception,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message and exception at the <c>Debug</c> level.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="logger">A logger implementation that will handle the message.</param>
            <param name="exception">An exception to be logged.</param>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.ILoggerExtensions.ConditionalDebug(NLog.ILogger,System.Exception,System.IFormatProvider,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message and exception at the <c>Debug</c> level.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="logger">A logger implementation that will handle the message.</param>
            <param name="exception">An exception to be logged.</param>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.ILoggerExtensions.ConditionalDebug(NLog.ILogger,System.String)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="logger">A logger implementation that will handle the message.</param>
            <param name="message">Log message.</param>
        </member>
        <member name="M:NLog.ILoggerExtensions.ConditionalDebug(NLog.ILogger,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified parameters.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="logger">A logger implementation that will handle the message.</param>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.ILoggerExtensions.ConditionalDebug(NLog.ILogger,System.IFormatProvider,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified parameters.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="logger">A logger implementation that will handle the message.</param>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.ILoggerExtensions.ConditionalDebug``1(NLog.ILogger,System.String,``0)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified parameter.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <typeparam name="TArgument">The type of the argument.</typeparam>
            <param name="logger">A logger implementation that will handle the message.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILoggerExtensions.ConditionalDebug``2(NLog.ILogger,System.String,``0,``1)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified parameters.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <param name="logger">A logger implementation that will handle the message.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
        </member>
        <member name="M:NLog.ILoggerExtensions.ConditionalDebug``3(NLog.ILogger,System.String,``0,``1,``2)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified parameters.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <typeparam name="TArgument3">The type of the third argument.</typeparam>
            <param name="logger">A logger implementation that will handle the message.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
            <param name="argument3">The third argument to format.</param>
        </member>
        <member name="M:NLog.ILoggerExtensions.ConditionalTrace``1(NLog.ILogger,``0)">
            <overloads>
            Writes the diagnostic message at the <c>Debug</c> level using the specified format provider and format parameters.
            </overloads>
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <typeparam name="T">Type of the value.</typeparam>
            <param name="logger">A logger implementation that will handle the message.</param>
            <param name="value">The value to be written.</param>
        </member>
        <member name="M:NLog.ILoggerExtensions.ConditionalTrace``1(NLog.ILogger,System.IFormatProvider,``0)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <typeparam name="T">Type of the value.</typeparam>
            <param name="logger">A logger implementation that will handle the message.</param>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="value">The value to be written.</param>
        </member>
        <member name="M:NLog.ILoggerExtensions.ConditionalTrace(NLog.ILogger,NLog.LogMessageGenerator)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="logger">A logger implementation that will handle the message.</param>
            <param name="messageFunc">A function returning message to be written. Function is not evaluated if logging is not enabled.</param>
        </member>
        <member name="M:NLog.ILoggerExtensions.ConditionalTrace(NLog.ILogger,System.Exception,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message and exception at the <c>Debug</c> level.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="logger">A logger implementation that will handle the message.</param>
            <param name="exception">An exception to be logged.</param>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.ILoggerExtensions.ConditionalTrace(NLog.ILogger,System.Exception,System.IFormatProvider,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message and exception at the <c>Debug</c> level.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="logger">A logger implementation that will handle the message.</param>
            <param name="exception">An exception to be logged.</param>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.ILoggerExtensions.ConditionalTrace(NLog.ILogger,System.String)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="logger">A logger implementation that will handle the message.</param>
            <param name="message">Log message.</param>
        </member>
        <member name="M:NLog.ILoggerExtensions.ConditionalTrace(NLog.ILogger,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified parameters.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="logger">A logger implementation that will handle the message.</param>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.ILoggerExtensions.ConditionalTrace(NLog.ILogger,System.IFormatProvider,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified parameters.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="logger">A logger implementation that will handle the message.</param>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.ILoggerExtensions.ConditionalTrace``1(NLog.ILogger,System.String,``0)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified parameter.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <typeparam name="TArgument">The type of the argument.</typeparam>
            <param name="logger">A logger implementation that will handle the message.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.ILoggerExtensions.ConditionalTrace``2(NLog.ILogger,System.String,``0,``1)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified parameters.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <param name="logger">A logger implementation that will handle the message.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
        </member>
        <member name="M:NLog.ILoggerExtensions.ConditionalTrace``3(NLog.ILogger,System.String,``0,``1,``2)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified parameters.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <typeparam name="TArgument3">The type of the third argument.</typeparam>
            <param name="logger">A logger implementation that will handle the message.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
            <param name="argument3">The third argument to format.</param>
        </member>
        <member name="M:NLog.ILoggerExtensions.Log(NLog.ILogger,NLog.LogLevel,System.Exception,NLog.LogMessageGenerator)">
            <summary>
            Writes the diagnostic message and exception at the specified level.
            </summary>
            <param name="logger">A logger implementation that will handle the message.</param>
            <param name="level">The log level.</param>
            <param name="exception">An exception to be logged.</param>
            <param name="messageFunc">A function returning message to be written. Function is not evaluated if logging is not enabled.</param>
        </member>
        <member name="M:NLog.ILoggerExtensions.Trace(NLog.ILogger,System.Exception,NLog.LogMessageGenerator)">
            <summary>
            Writes the diagnostic message and exception at the <c>Trace</c> level.
            </summary>
            <param name="logger">A logger implementation that will handle the message.</param>
            <param name="exception">An exception to be logged.</param>
            <param name="messageFunc">A function returning message to be written. Function is not evaluated if logging is not enabled.</param>
        </member>
        <member name="M:NLog.ILoggerExtensions.Debug(NLog.ILogger,System.Exception,NLog.LogMessageGenerator)">
            <summary>
            Writes the diagnostic message and exception at the <c>Debug</c> level.
            </summary>
            <param name="logger">A logger implementation that will handle the message.</param>
            <param name="exception">An exception to be logged.</param>
            <param name="messageFunc">A function returning message to be written. Function is not evaluated if logging is not enabled.</param>
        </member>
        <member name="M:NLog.ILoggerExtensions.Info(NLog.ILogger,System.Exception,NLog.LogMessageGenerator)">
            <summary>
            Writes the diagnostic message and exception at the <c>Info</c> level.
            </summary>
            <param name="logger">A logger implementation that will handle the message.</param>
            <param name="exception">An exception to be logged.</param>
            <param name="messageFunc">A function returning message to be written. Function is not evaluated if logging is not enabled.</param>
        </member>
        <member name="M:NLog.ILoggerExtensions.Warn(NLog.ILogger,System.Exception,NLog.LogMessageGenerator)">
            <summary>
            Writes the diagnostic message and exception at the <c>Warn</c> level.
            </summary>
            <param name="logger">A logger implementation that will handle the message.</param>
            <param name="exception">An exception to be logged.</param>
            <param name="messageFunc">A function returning message to be written. Function is not evaluated if logging is not enabled.</param>
        </member>
        <member name="M:NLog.ILoggerExtensions.Error(NLog.ILogger,System.Exception,NLog.LogMessageGenerator)">
            <summary>
            Writes the diagnostic message and exception at the <c>Error</c> level.
            </summary>
            <param name="logger">A logger implementation that will handle the message.</param>
            <param name="exception">An exception to be logged.</param>
            <param name="messageFunc">A function returning message to be written. Function is not evaluated if logging is not enabled.</param>
        </member>
        <member name="M:NLog.ILoggerExtensions.Fatal(NLog.ILogger,System.Exception,NLog.LogMessageGenerator)">
            <summary>
            Writes the diagnostic message and exception at the <c>Fatal</c> level.
            </summary>
            <param name="logger">A logger implementation that will handle the message.</param>
            <param name="exception">An exception to be logged.</param>
            <param name="messageFunc">A function returning message to be written. Function is not evaluated if logging is not enabled.</param>
        </member>
        <member name="T:NLog.Internal.Fakeables.AppDomainWrapper">
            <summary>
            Adapter for <see cref="T:System.AppDomain"/> to <see cref="T:NLog.Internal.Fakeables.IAppDomain"/>
            </summary>
        </member>
        <member name="M:NLog.Internal.Fakeables.AppDomainWrapper.#ctor(System.AppDomain)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Internal.Fakeables.AppDomainWrapper"/> class.
            </summary>
            <param name="appDomain">The <see cref="T:System.AppDomain"/> to wrap.</param>
        </member>
        <member name="P:NLog.Internal.Fakeables.AppDomainWrapper.CurrentDomain">
            <summary>
            Creates an AppDomainWrapper for the current <see cref="T:System.AppDomain"/>
            </summary>
        </member>
        <member name="P:NLog.Internal.Fakeables.AppDomainWrapper.BaseDirectory">
            <summary>
            Gets or sets the base directory that the assembly resolver uses to probe for assemblies.
            </summary>
        </member>
        <member name="P:NLog.Internal.Fakeables.AppDomainWrapper.ConfigurationFile">
            <summary>
            Gets or sets the name of the configuration file for an application domain.
            </summary>
        </member>
        <member name="P:NLog.Internal.Fakeables.AppDomainWrapper.PrivateBinPath">
            <summary>
            Gets or sets the list of directories under the application base directory that are probed for private assemblies.
            </summary>
        </member>
        <member name="P:NLog.Internal.Fakeables.AppDomainWrapper.FriendlyName">
            <summary>
            Gets or set the friendly name.
            </summary>
        </member>
        <member name="P:NLog.Internal.Fakeables.AppDomainWrapper.Id">
            <summary>
            Gets an integer that uniquely identifies the application domain within the process.
            </summary>
        </member>
        <member name="M:NLog.Internal.Fakeables.AppDomainWrapper.GetAssemblies">
            <summary>
            Gets the assemblies that have been loaded into the execution context of this application domain.
            </summary>
            <returns>A list of assemblies in this application domain.</returns>
        </member>
        <member name="E:NLog.Internal.Fakeables.AppDomainWrapper.ProcessExit">
            <summary>
            Process exit event.
            </summary>
        </member>
        <member name="E:NLog.Internal.Fakeables.AppDomainWrapper.DomainUnload">
            <summary>
            Domain unloaded event.
            </summary>
        </member>
        <member name="P:NLog.Internal.Fakeables.AppEnvironmentWrapper.EntryAssemblyLocation">
            <inheritdoc/>
        </member>
        <member name="P:NLog.Internal.Fakeables.AppEnvironmentWrapper.EntryAssemblyFileName">
            <inheritdoc/>
        </member>
        <member name="P:NLog.Internal.Fakeables.AppEnvironmentWrapper.CurrentProcessFilePath">
            <inheritdoc/>
        </member>
        <member name="P:NLog.Internal.Fakeables.AppEnvironmentWrapper.CurrentProcessBaseName">
            <inheritdoc/>
        </member>
        <member name="P:NLog.Internal.Fakeables.AppEnvironmentWrapper.CurrentProcessId">
            <inheritdoc/>
        </member>
        <member name="P:NLog.Internal.Fakeables.AppEnvironmentWrapper.AppDomainBaseDirectory">
            <inheritdoc/>
        </member>
        <member name="P:NLog.Internal.Fakeables.AppEnvironmentWrapper.AppDomainConfigurationFile">
            <inheritdoc/>
        </member>
        <member name="P:NLog.Internal.Fakeables.AppEnvironmentWrapper.AppDomainFriendlyName">
            <inheritdoc/>
        </member>
        <member name="P:NLog.Internal.Fakeables.AppEnvironmentWrapper.AppDomainId">
            <inheritdoc/>
        </member>
        <member name="P:NLog.Internal.Fakeables.AppEnvironmentWrapper.AppDomainPrivateBinPath">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Internal.Fakeables.AppEnvironmentWrapper.GetAppDomainRuntimeAssemblies">
            <inheritdoc/>
        </member>
        <member name="E:NLog.Internal.Fakeables.AppEnvironmentWrapper.ProcessExit">
            <inheritdoc/>
        </member>
        <member name="P:NLog.Internal.Fakeables.AppEnvironmentWrapper.UserTempFilePath">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Internal.Fakeables.AppEnvironmentWrapper.FileExists(System.String)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Internal.Fakeables.AppEnvironmentWrapper.LoadXmlFile(System.String)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Internal.Fakeables.AppEnvironmentWrapper.FixFilePathWithLongUNC(System.String)">
            <summary>
            Long UNC paths does not allow relative-path-logic using '..', and also cannot be loaded into Uri by XmlReader
            </summary>
        </member>
        <member name="T:NLog.Internal.Fakeables.IAppDomain">
            <summary>
            Interface for fakeable of the current AppDomain.
            </summary>
        </member>
        <member name="P:NLog.Internal.Fakeables.IAppDomain.BaseDirectory">
            <summary>
            Gets or sets the base directory that the assembly resolver uses to probe for assemblies.
            </summary>
        </member>
        <member name="P:NLog.Internal.Fakeables.IAppDomain.ConfigurationFile">
            <summary>
            Gets or sets the name of the configuration file for an application domain.
            </summary>
        </member>
        <member name="P:NLog.Internal.Fakeables.IAppDomain.PrivateBinPath">
            <summary>
            Gets or sets the list of directories under the application base directory that are probed for private assemblies.
            </summary>
        </member>
        <member name="P:NLog.Internal.Fakeables.IAppDomain.FriendlyName">
            <summary>
            Gets or set the friendly name.
            </summary>
        </member>
        <member name="P:NLog.Internal.Fakeables.IAppDomain.Id">
            <summary>
            Gets an integer that uniquely identifies the application domain within the process.
            </summary>
        </member>
        <member name="M:NLog.Internal.Fakeables.IAppDomain.GetAssemblies">
            <summary>
            Gets the assemblies that have been loaded into the execution context of this application domain.
            </summary>
            <returns>A list of assemblies in this application domain.</returns>
        </member>
        <member name="E:NLog.Internal.Fakeables.IAppDomain.ProcessExit">
            <summary>
            Process exit event.
            </summary>
        </member>
        <member name="E:NLog.Internal.Fakeables.IAppDomain.DomainUnload">
            <summary>
            Domain unloaded event.
            </summary>
        </member>
        <member name="T:NLog.Internal.Fakeables.IAppEnvironment">
            <summary>
            Abstract calls for the application environment
            </summary>
        </member>
        <member name="P:NLog.Internal.Fakeables.IAppEnvironment.CurrentProcessBaseName">
            <summary>
            Gets current process name (excluding filename extension, if any).
            </summary>
        </member>
        <member name="E:NLog.Internal.Fakeables.IAppEnvironment.ProcessExit">
            <summary>
            Process exit event.
            </summary>
        </member>
        <member name="T:NLog.Internal.Fakeables.IFileSystem">
            <summary>
            Abstract calls to FileSystem
            </summary>
        </member>
        <member name="M:NLog.Internal.Fakeables.IFileSystem.FileExists(System.String)">
            <summary>Determines whether the specified file exists.</summary>
            <param name="path">The file to check.</param>
        </member>
        <member name="M:NLog.Internal.Fakeables.IFileSystem.LoadXmlFile(System.String)">
            <summary>Returns the content of the specified file</summary>
            <param name="path">The file to load.</param>
        </member>
        <member name="T:NLog.Internal.AppendBuilderCreator">
            <summary>
            Allocates new builder and appends to the provided target builder on dispose
            </summary>
        </member>
        <member name="P:NLog.Internal.AppendBuilderCreator.Builder">
            <summary>
            Access the new builder allocated
            </summary>
        </member>
        <member name="T:NLog.Internal.AssemblyHelpers">
            <summary>
            Helpers for <see cref="T:System.Reflection.Assembly"/>.
            </summary>
        </member>
        <member name="M:NLog.Internal.AssemblyHelpers.SafeGetTypes(System.Reflection.Assembly)">
            <summary>
            Gets all usable exported types from the given assembly.
            </summary>
            <param name="assembly">Assembly to scan.</param>
            <returns>Usable types from the given assembly.</returns>
            <remarks>Types which cannot be loaded are skipped.</remarks>
        </member>
        <member name="T:NLog.Internal.AsyncHelpersTask">
            <summary>
            Forward declare of system delegate type for use by other classes
            </summary>
        </member>
        <member name="T:NLog.Internal.AsyncOperationCounter">
            <summary>
            Keeps track of pending operation count, and can notify when pending operation count reaches zero
            </summary>
        </member>
        <member name="M:NLog.Internal.AsyncOperationCounter.BeginOperation">
            <summary>
            Mark operation has started
            </summary>
        </member>
        <member name="M:NLog.Internal.AsyncOperationCounter.CompleteOperation(System.Exception)">
            <summary>
            Mark operation has completed
            </summary>
            <param name="exception">Exception coming from the completed operation [optional]</param>
        </member>
        <member name="M:NLog.Internal.AsyncOperationCounter.RegisterCompletionNotification(NLog.Common.AsyncContinuation)">
            <summary>
            Registers an AsyncContinuation to be called when all pending operations have completed
            </summary>
            <param name="asyncContinuation">Invoked on completion</param>
            <returns>AsyncContinuation operation</returns>
        </member>
        <member name="M:NLog.Internal.AsyncOperationCounter.Clear">
            <summary>
            Clear o
            </summary>
        </member>
        <member name="M:NLog.Internal.CallSiteInformation.AddCallSiteHiddenAssembly(System.Reflection.Assembly)">
            <summary>
            Adds the given assembly which will be skipped
            when NLog is trying to find the calling method on stack trace.
            </summary>
            <param name="assembly">The assembly to skip.</param>
        </member>
        <member name="M:NLog.Internal.CallSiteInformation.SetStackTrace(System.Diagnostics.StackTrace,System.Nullable{System.Int32},System.Type)">
            <summary>
            Sets the stack trace for the event info.
            </summary>
            <param name="stackTrace">The stack trace.</param>
            <param name="userStackFrame">Index of the first user stack frame within the stack trace.</param>
            <param name="loggerType">Type of the logger or logger wrapper. This is still Logger if it's a subclass of Logger.</param>
        </member>
        <member name="M:NLog.Internal.CallSiteInformation.SetCallerInfo(System.String,System.String,System.String,System.Int32)">
            <summary>
            Sets the details retrieved from the Caller Information Attributes
            </summary>
            <param name="callerClassName"></param>
            <param name="callerMethodName"></param>
            <param name="callerFilePath"></param>
            <param name="callerLineNumber"></param>
        </member>
        <member name="P:NLog.Internal.CallSiteInformation.UserStackFrame">
             <summary>
             Obsolete and replaced by <see cref="P:NLog.LogEventInfo.CallerMemberName"/> or ${callsite} with NLog v5.3.
            
             Gets the stack frame of the method that did the logging.
             </summary>
        </member>
        <member name="P:NLog.Internal.CallSiteInformation.UserStackFrameNumber">
            <summary>
            Gets the number index of the stack frame that represents the user
            code (not the NLog code).
            </summary>
        </member>
        <member name="P:NLog.Internal.CallSiteInformation.UserStackFrameNumberLegacy">
            <summary>
            Legacy attempt to skip async MoveNext, but caused source file line number to be lost
            </summary>
        </member>
        <member name="P:NLog.Internal.CallSiteInformation.StackTrace">
            <summary>
            Gets the entire stack trace.
            </summary>
        </member>
        <member name="M:NLog.Internal.CallSiteInformation.FindCallingMethodOnStackTrace(System.Diagnostics.StackFrame[],System.Type)">
            <summary>
             Finds first user stack frame in a stack trace
            </summary>
            <param name="stackFrames">The stack trace of the logging method invocation</param>
            <param name="loggerType">Type of the logger or logger wrapper. This is still Logger if it's a subclass of Logger.</param>
            <returns>Index of the first user stack frame or 0 if all stack frames are non-user</returns>
        </member>
        <member name="M:NLog.Internal.CallSiteInformation.SkipToUserStackFrameLegacy(System.Diagnostics.StackFrame[],System.Int32)">
            <summary>
            This is only done for legacy reason, as the correct method-name and line-number should be extracted from the MoveNext-StackFrame
            </summary>
            <param name="stackFrames">The stack trace of the logging method invocation</param>
            <param name="firstUserStackFrame">Starting point for skipping async MoveNext-frames</param>
        </member>
        <member name="M:NLog.Internal.CallSiteInformation.SkipStackFrameWhenHidden(System.Reflection.MethodBase)">
            <summary>
            Skip StackFrame when from hidden Assembly / ClassType
            </summary>
        </member>
        <member name="M:NLog.Internal.CallSiteInformation.SkipStackFrameWhenLoggerType(System.Reflection.MethodBase,System.Type)">
            <summary>
            Skip StackFrame when type of the logger
            </summary>
        </member>
        <member name="M:NLog.Internal.CollectionExtensions.Filter``2(System.Collections.Generic.IList{``0},``1,System.Func{``0,``1,System.Boolean})">
            <summary>
            Memory optimized filtering
            </summary>
            <remarks>Passing state too avoid delegate capture and memory-allocations.</remarks>
        </member>
        <member name="T:NLog.Internal.ConfigurationManager">
            <summary>
            Internal configuration manager used to read .NET configuration files.
            Just a wrapper around the BCL ConfigurationManager, but used to enable
            unit testing.
            </summary>
        </member>
        <member name="T:NLog.Internal.DictionaryEntryEnumerable">
            <summary>
            Ensures that IDictionary.GetEnumerator returns DictionaryEntry values
            </summary>
        </member>
        <member name="F:NLog.Internal.EncodingHelpers.Utf8BOM">
            <summary>
            UTF-8 BOM 239, 187, 191
            </summary>
        </member>
        <member name="T:NLog.Internal.EnvironmentHelper">
            <summary>
            Safe way to get environment variables.
            </summary>
        </member>
        <member name="T:NLog.Internal.ExceptionHelper">
            <summary>
            Helper class for dealing with exceptions.
            </summary>
        </member>
        <member name="M:NLog.Internal.ExceptionHelper.MarkAsLoggedToInternalLogger(System.Exception)">
            <summary>
            Mark this exception as logged to the <see cref="T:NLog.Common.InternalLogger"/>.
            </summary>
            <param name="exception"></param>
            <returns></returns>
        </member>
        <member name="M:NLog.Internal.ExceptionHelper.IsLoggedToInternalLogger(System.Exception)">
            <summary>
            Is this exception logged to the <see cref="T:NLog.Common.InternalLogger"/>?
            </summary>
            <param name="exception"></param>
            <returns><c>true</c>if the <paramref name="exception"/> has been logged to the <see cref="T:NLog.Common.InternalLogger"/>.</returns>
        </member>
        <member name="M:NLog.Internal.ExceptionHelper.MustBeRethrown(System.Exception,NLog.Common.IInternalLoggerContext,System.String)">
             <summary>
             Determines whether the exception must be rethrown and logs the error to the <see cref="T:NLog.Common.InternalLogger"/> if <see cref="M:NLog.Internal.ExceptionHelper.IsLoggedToInternalLogger(System.Exception)"/> is <c>false</c>.
            
             Advised to log first the error to the <see cref="T:NLog.Common.InternalLogger"/> before calling this method.
             </summary>
             <param name="exception">The exception to check.</param>
             <param name="loggerContext">Target Object context of the exception.</param>
             <param name="callerMemberName">Target Method context of the exception.</param>
             <returns><c>true</c>if the <paramref name="exception"/> must be rethrown, <c>false</c> otherwise.</returns>
        </member>
        <member name="M:NLog.Internal.ExceptionHelper.MustBeRethrownImmediately(System.Exception)">
             <summary>
             Determines whether the exception must be rethrown immediately, without logging the error to the <see cref="T:NLog.Common.InternalLogger"/>.
            
             Only used this method in special cases.
             </summary>
             <param name="exception">The exception to check.</param>
             <returns><c>true</c>if the <paramref name="exception"/> must be rethrown, <c>false</c> otherwise.</returns>
        </member>
        <member name="T:NLog.Internal.ExceptionMessageFormatProvider">
            <summary>
            FormatProvider that renders an exception-object as $"{ex.GetType()}: {ex.Message}"
            </summary>
        </member>
        <member name="T:NLog.Internal.FactoryHelper">
            <summary>
            Object construction helper.
            </summary>
        </member>
        <member name="T:NLog.Internal.FileAppenders.BaseFileAppender">
            <summary>
            Base class for optimized file appenders.
            </summary>
        </member>
        <member name="M:NLog.Internal.FileAppenders.BaseFileAppender.#ctor(System.String,NLog.Internal.FileAppenders.ICreateFileParameters)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Internal.FileAppenders.BaseFileAppender" /> class.
            </summary>
            <param name="fileName">Name of the file.</param>
            <param name="createParameters">The create parameters.</param>
        </member>
        <member name="P:NLog.Internal.FileAppenders.BaseFileAppender.FileName">
            <summary>
            Gets the path of the file, including file extension.
            </summary>
            <value>The name of the file.</value>
        </member>
        <member name="P:NLog.Internal.FileAppenders.BaseFileAppender.CreationTimeUtc">
            <summary>
            Gets or sets the creation time for a file associated with the appender. The time returned is in Coordinated
            Universal Time [UTC] standard.
            </summary>
            <returns>The creation time of the file.</returns>
        </member>
        <member name="P:NLog.Internal.FileAppenders.BaseFileAppender.CreationTimeSource">
            <summary>
            Gets or sets the creation time for a file associated with the appender. Synchronized by <see cref="P:NLog.Internal.FileAppenders.BaseFileAppender.CreationTimeUtc"/>
            The time format is based on <see cref="T:NLog.Time.TimeSource" />
            </summary>
        </member>
        <member name="P:NLog.Internal.FileAppenders.BaseFileAppender.OpenTimeUtc">
            <summary>
            Gets the last time the file associated with the appender is opened. The time returned is in Coordinated
            Universal Time [UTC] standard.
            </summary>
            <returns>The time the file was last opened.</returns>
        </member>
        <member name="P:NLog.Internal.FileAppenders.BaseFileAppender.CreateFileParameters">
            <summary>
            Gets the file creation parameters.
            </summary>
            <value>The file creation parameters.</value>
        </member>
        <member name="M:NLog.Internal.FileAppenders.BaseFileAppender.Write(System.Byte[])">
            <summary>
            Writes the specified bytes.
            </summary>
            <param name="bytes">The bytes.</param>
        </member>
        <member name="M:NLog.Internal.FileAppenders.BaseFileAppender.Write(System.Byte[],System.Int32,System.Int32)">
            <summary>
            Writes the specified bytes to a file.
            </summary>
            <param name="bytes">The bytes array.</param>
            <param name="offset">The bytes array offset.</param>
            <param name="count">The number of bytes.</param>
        </member>
        <member name="M:NLog.Internal.FileAppenders.BaseFileAppender.Flush">
            <summary>
            Flushes this file-appender instance.
            </summary>
        </member>
        <member name="M:NLog.Internal.FileAppenders.BaseFileAppender.Close">
            <summary>
            Closes this file-appender instance.
            </summary>
        </member>
        <member name="M:NLog.Internal.FileAppenders.BaseFileAppender.GetFileCreationTimeUtc">
            <summary>
            Gets the creation time for a file associated with the appender. The time returned is in Coordinated Universal
            Time [UTC] standard.
            </summary>
            <returns>The file creation time.</returns>
        </member>
        <member name="M:NLog.Internal.FileAppenders.BaseFileAppender.GetFileLength">
            <summary>
            Gets the length in bytes of the file associated with the appender.
            </summary>
            <returns>A long value representing the length of the file in bytes.</returns>
        </member>
        <member name="M:NLog.Internal.FileAppenders.BaseFileAppender.Dispose">
            <summary>
            Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
            </summary>
        </member>
        <member name="M:NLog.Internal.FileAppenders.BaseFileAppender.Dispose(System.Boolean)">
            <summary>
            Releases unmanaged and - optionally - managed resources.
            </summary>
            <param name="disposing">True to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
        </member>
        <member name="M:NLog.Internal.FileAppenders.BaseFileAppender.CreateFileStream(System.Boolean,System.Int32)">
            <summary>
            Creates the file stream.
            </summary>
            <param name="allowFileSharedWriting">If set to <c>true</c> sets the file stream to allow shared writing.</param>
            <param name="overrideBufferSize">If larger than 0 then it will be used instead of the default BufferSize for the FileStream.</param>
            <returns>A <see cref="T:System.IO.FileStream"/> object which can be used to write to the file.</returns>
        </member>
        <member name="T:NLog.Internal.FileAppenders.BaseMutexFileAppender">
             <summary>
             Base class for optimized file appenders which require the usage of a mutex.
            
             It is possible to use this class as replacement of BaseFileAppender and the mutex functionality
             is not enforced to the implementing subclasses.
             </summary>
        </member>
        <member name="M:NLog.Internal.FileAppenders.BaseMutexFileAppender.#ctor(System.String,NLog.Internal.FileAppenders.ICreateFileParameters)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Internal.FileAppenders.BaseMutexFileAppender" /> class.
            </summary>
            <param name="fileName">Name of the file.</param>
            <param name="createParameters">The create parameters.</param>
        </member>
        <member name="P:NLog.Internal.FileAppenders.BaseMutexFileAppender.ArchiveMutex">
            <summary>
            Gets the mutually-exclusive lock for archiving files.
            </summary>
            <value>The mutex for archiving.</value>
        </member>
        <member name="M:NLog.Internal.FileAppenders.BaseMutexFileAppender.Dispose(System.Boolean)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Internal.FileAppenders.BaseMutexFileAppender.CreateSharableMutex(System.String)">
            <summary>
            Creates a mutex that is sharable by more than one process.
            </summary>
            <param name="mutexNamePrefix">The prefix to use for the name of the mutex.</param>
            <returns>A <see cref="T:System.Threading.Mutex"/> object which is sharable by multiple processes.</returns>
        </member>
        <member name="T:NLog.Internal.FileAppenders.CountingSingleProcessFileAppender">
            <summary>
            Implementation of <see cref="T:NLog.Internal.FileAppenders.BaseFileAppender"/> which caches
            file information.
            </summary>
        </member>
        <member name="M:NLog.Internal.FileAppenders.CountingSingleProcessFileAppender.#ctor(System.String,NLog.Internal.FileAppenders.ICreateFileParameters)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Internal.FileAppenders.CountingSingleProcessFileAppender" /> class.
            </summary>
            <param name="fileName">Name of the file.</param>
            <param name="parameters">The parameters.</param>
        </member>
        <member name="M:NLog.Internal.FileAppenders.CountingSingleProcessFileAppender.Close">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Internal.FileAppenders.CountingSingleProcessFileAppender.Flush">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Internal.FileAppenders.CountingSingleProcessFileAppender.GetFileCreationTimeUtc">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Internal.FileAppenders.CountingSingleProcessFileAppender.GetFileLength">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Internal.FileAppenders.CountingSingleProcessFileAppender.Write(System.Byte[],System.Int32,System.Int32)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.Internal.FileAppenders.CountingSingleProcessFileAppender.Factory">
            <summary>
            Factory class which creates <see cref="T:NLog.Internal.FileAppenders.CountingSingleProcessFileAppender"/> objects.
            </summary>
        </member>
        <member name="M:NLog.Internal.FileAppenders.CountingSingleProcessFileAppender.Factory.NLog#Internal#FileAppenders#IFileAppenderFactory#Open(System.String,NLog.Internal.FileAppenders.ICreateFileParameters)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.Internal.FileAppenders.FileAppenderCache">
            <summary>
            Maintains a collection of file appenders usually associated with file targets.
            </summary>
        </member>
        <member name="F:NLog.Internal.FileAppenders.FileAppenderCache.Empty">
            <summary>
            An "empty" instance of the <see cref="T:NLog.Internal.FileAppenders.FileAppenderCache"/> class with zero size and empty list of appenders.
            </summary>
        </member>
        <member name="M:NLog.Internal.FileAppenders.FileAppenderCache.#ctor">
            <summary>
            Initializes a new "empty" instance of the <see cref="T:NLog.Internal.FileAppenders.FileAppenderCache"/> class with zero size and empty
            list of appenders.
            </summary>
        </member>
        <member name="M:NLog.Internal.FileAppenders.FileAppenderCache.#ctor(System.Int32,NLog.Internal.FileAppenders.IFileAppenderFactory,NLog.Internal.FileAppenders.ICreateFileParameters)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Internal.FileAppenders.FileAppenderCache"/> class.
            </summary>
            <remarks>
            The size of the list should be positive. No validations are performed during initialization as it is an
            internal class.
            </remarks>
            <param name="size">Total number of appenders allowed in list.</param>
            <param name="appenderFactory">Factory used to create each appender.</param>
            <param name="createFileParams">Parameters used for creating a file.</param>
        </member>
        <member name="P:NLog.Internal.FileAppenders.FileAppenderCache.ArchiveFilePatternToWatch">
            <summary>
            The archive file path pattern that is used to detect when archiving occurs.
            </summary>
        </member>
        <member name="M:NLog.Internal.FileAppenders.FileAppenderCache.InvalidateAppendersForArchivedFiles">
            <summary>
            Invalidates appenders for all files that were archived.
            </summary>
        </member>
        <member name="P:NLog.Internal.FileAppenders.FileAppenderCache.CreateFileParameters">
            <summary>
            Gets the parameters which will be used for creating a file.
            </summary>
        </member>
        <member name="P:NLog.Internal.FileAppenders.FileAppenderCache.Factory">
            <summary>
            Gets the file appender factory used by all the appenders in this list.
            </summary>
        </member>
        <member name="P:NLog.Internal.FileAppenders.FileAppenderCache.Size">
            <summary>
            Gets the number of appenders which the list can hold.
            </summary>
        </member>
        <member name="E:NLog.Internal.FileAppenders.FileAppenderCache.CheckCloseAppenders">
            <summary>
            Subscribe to background monitoring of active file appenders
            </summary>
        </member>
        <member name="M:NLog.Internal.FileAppenders.FileAppenderCache.AllocateAppender(System.String)">
            <summary>
            It allocates the first slot in the list when the file name does not already in the list and clean up any
            unused slots.
            </summary>
            <param name="fileName">File name associated with a single appender.</param>
            <returns>The allocated appender.</returns>
        </member>
        <member name="M:NLog.Internal.FileAppenders.FileAppenderCache.CloseAppenders(System.String)">
            <summary>
            Close all the allocated appenders.
            </summary>
        </member>
        <member name="M:NLog.Internal.FileAppenders.FileAppenderCache.CloseExpiredAppenders(System.DateTime)">
            <summary>
            Close the allocated appenders initialized before the supplied time.
            </summary>
            <param name="expireTimeUtc">The time which prior the appenders considered expired</param>
        </member>
        <member name="M:NLog.Internal.FileAppenders.FileAppenderCache.FlushAppenders">
            <summary>
            Flush all the allocated appenders.
            </summary>
        </member>
        <member name="M:NLog.Internal.FileAppenders.FileAppenderCache.GetFileLastWriteTimeUtc(System.String)">
            <summary>
            File Archive Logic uses the File-Creation-TimeStamp to detect if time to archive, and the File-LastWrite-Timestamp to name the archive-file.
            </summary>
            <remarks>
            NLog always closes all relevant appenders during archive operation, so no need to lookup file-appender
            </remarks>
        </member>
        <member name="M:NLog.Internal.FileAppenders.FileAppenderCache.InvalidateAppender(System.String)">
            <summary>
            Closes the specified appender and removes it from the list.
            </summary>
            <param name="filePath">File name of the appender to be closed.</param>
            <returns>File Appender that matched the filePath (null if none found)</returns>
        </member>
        <member name="T:NLog.Internal.FileAppenders.ICreateFileParameters">
            <summary>
            Interface that provides parameters for create file function.
            </summary>
        </member>
        <member name="P:NLog.Internal.FileAppenders.ICreateFileParameters.FileOpenRetryCount">
            <summary>
            Gets or sets the delay in milliseconds to wait before attempting to write to the file again.
            </summary>
        </member>
        <member name="P:NLog.Internal.FileAppenders.ICreateFileParameters.FileOpenRetryDelay">
            <summary>
            Gets or sets the number of times the write is appended on the file before NLog
            discards the log message.
            </summary>
        </member>
        <member name="P:NLog.Internal.FileAppenders.ICreateFileParameters.ConcurrentWrites">
            <summary>
            Gets or sets a value indicating whether concurrent writes to the log file by multiple processes on the same host.
            </summary>
            <remarks>
            This makes multi-process logging possible. NLog uses a special technique
            that lets it keep the files open for writing.
            </remarks>
        </member>
        <member name="P:NLog.Internal.FileAppenders.ICreateFileParameters.CreateDirs">
            <summary>
            Gets or sets a value indicating whether to create directories if they do not exist.
            </summary>
            <remarks>
            Setting this to false may improve performance a bit, but you'll receive an error
            when attempting to write to a directory that's not present.
            </remarks>
        </member>
        <member name="P:NLog.Internal.FileAppenders.ICreateFileParameters.EnableFileDelete">
            <summary>
            Gets or sets a value indicating whether to enable log file(s) to be deleted.
            </summary>
        </member>
        <member name="P:NLog.Internal.FileAppenders.ICreateFileParameters.BufferSize">
            <summary>
            Gets or sets the log file buffer size in bytes.
            </summary>
        </member>
        <member name="P:NLog.Internal.FileAppenders.ICreateFileParameters.ForceManaged">
            <summary>
            Gets or set a value indicating whether a managed file stream is forced, instead of using the native implementation.
            </summary>
        </member>
        <member name="P:NLog.Internal.FileAppenders.ICreateFileParameters.FileAttributes">
            <summary>
            Gets or sets the file attributes (Windows only).
            </summary>
        </member>
        <member name="P:NLog.Internal.FileAppenders.ICreateFileParameters.IsArchivingEnabled">
            <summary>
            Should archive mutex be created?
            </summary>
        </member>
        <member name="P:NLog.Internal.FileAppenders.ICreateFileParameters.EnableFileDeleteSimpleMonitor">
            <summary>
            Should manual simple detection of file deletion be enabled?
            </summary>
        </member>
        <member name="P:NLog.Internal.FileAppenders.IFileAppenderCache.CreateFileParameters">
            <summary>
            Gets the parameters which will be used for creating a file.
            </summary>
        </member>
        <member name="P:NLog.Internal.FileAppenders.IFileAppenderCache.Factory">
            <summary>
            Gets the file appender factory used by all the appenders in this list.
            </summary>
        </member>
        <member name="P:NLog.Internal.FileAppenders.IFileAppenderCache.Size">
            <summary>
            Gets the number of appenders which the list can hold.
            </summary>
        </member>
        <member name="E:NLog.Internal.FileAppenders.IFileAppenderCache.CheckCloseAppenders">
            <summary>
            Subscribe to background monitoring of active file appenders
            </summary>
        </member>
        <member name="M:NLog.Internal.FileAppenders.IFileAppenderCache.AllocateAppender(System.String)">
            <summary>
            It allocates the first slot in the list when the file name does not already in the list and clean up any
            unused slots.
            </summary>
            <param name="fileName">File name associated with a single appender.</param>
            <returns>The allocated appender.</returns>
        </member>
        <member name="M:NLog.Internal.FileAppenders.IFileAppenderCache.CloseAppenders(System.String)">
            <summary>
            Close all the allocated appenders.
            </summary>
        </member>
        <member name="M:NLog.Internal.FileAppenders.IFileAppenderCache.CloseExpiredAppenders(System.DateTime)">
            <summary>
            Close the allocated appenders initialized before the supplied time.
            </summary>
            <param name="expireTimeUtc">The time which prior the appenders considered expired</param>
        </member>
        <member name="M:NLog.Internal.FileAppenders.IFileAppenderCache.FlushAppenders">
            <summary>
            Flush all the allocated appenders.
            </summary>
        </member>
        <member name="M:NLog.Internal.FileAppenders.IFileAppenderCache.GetFileLastWriteTimeUtc(System.String)">
            <summary>
            File Archive Logic uses the File-Creation-TimeStamp to detect if time to archive, and the File-LastWrite-Timestamp to name the archive-file.
            </summary>
            <remarks>
            NLog always closes all relevant appenders during archive operation, so no need to lookup file-appender
            </remarks>
        </member>
        <member name="M:NLog.Internal.FileAppenders.IFileAppenderCache.InvalidateAppender(System.String)">
            <summary>
            Closes the specified appender and removes it from the list.
            </summary>
            <param name="filePath">File name of the appender to be closed.</param>
            <returns>File Appender that matched the filePath (null if none found)</returns>
        </member>
        <member name="P:NLog.Internal.FileAppenders.IFileAppenderCache.ArchiveFilePatternToWatch">
            <summary>
            The archive file path pattern that is used to detect when archiving occurs.
            </summary>
        </member>
        <member name="M:NLog.Internal.FileAppenders.IFileAppenderCache.InvalidateAppendersForArchivedFiles">
            <summary>
            Invalidates appenders for all files that were archived.
            </summary>
        </member>
        <member name="T:NLog.Internal.FileAppenders.IFileAppenderFactory">
            <summary>
            Interface implemented by all factories capable of creating file appenders.
            </summary>
        </member>
        <member name="M:NLog.Internal.FileAppenders.IFileAppenderFactory.Open(System.String,NLog.Internal.FileAppenders.ICreateFileParameters)">
            <summary>
            Opens the appender for given file name and parameters.
            </summary>
            <param name="fileName">Name of the file.</param>
            <param name="parameters">Creation parameters.</param>
            <returns>Instance of <see cref="T:NLog.Internal.FileAppenders.BaseFileAppender"/> which can be used to write to the file.</returns>
        </member>
        <member name="T:NLog.Internal.FileAppenders.MutexMultiProcessFileAppender">
            <summary>
            Provides a multi process-safe atomic file appends while
            keeping the files open.
            </summary>
            <remarks>
            On Unix you can get all the appends to be atomic, even when multiple
            processes are trying to write to the same file, because setting the file
            pointer to the end of the file and appending can be made one operation.
            On Win32 we need to maintain some synchronization between processes
            (global named mutex is used for this)
            </remarks>
        </member>
        <member name="M:NLog.Internal.FileAppenders.MutexMultiProcessFileAppender.#ctor(System.String,NLog.Internal.FileAppenders.ICreateFileParameters)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Internal.FileAppenders.MutexMultiProcessFileAppender" /> class.
            </summary>
            <param name="fileName">Name of the file.</param>
            <param name="parameters">The parameters.</param>
        </member>
        <member name="M:NLog.Internal.FileAppenders.MutexMultiProcessFileAppender.Write(System.Byte[],System.Int32,System.Int32)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Internal.FileAppenders.MutexMultiProcessFileAppender.Close">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Internal.FileAppenders.MutexMultiProcessFileAppender.Flush">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Internal.FileAppenders.MutexMultiProcessFileAppender.GetFileCreationTimeUtc">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Internal.FileAppenders.MutexMultiProcessFileAppender.GetFileLength">
            <inheritdoc/>
        </member>
        <member name="T:NLog.Internal.FileAppenders.MutexMultiProcessFileAppender.Factory">
            <summary>
            Factory class.
            </summary>
        </member>
        <member name="M:NLog.Internal.FileAppenders.MutexMultiProcessFileAppender.Factory.NLog#Internal#FileAppenders#IFileAppenderFactory#Open(System.String,NLog.Internal.FileAppenders.ICreateFileParameters)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.Internal.FileAppenders.NullAppender">
            <summary>
            Appender used to discard data for the FileTarget.
            Used mostly for testing entire stack except the actual writing to disk.
            Throws away all data.
            </summary>
        </member>
        <member name="T:NLog.Internal.FileAppenders.NullAppender.Factory">
            <summary>
            Factory class.
            </summary>
        </member>
        <member name="M:NLog.Internal.FileAppenders.NullAppender.Factory.NLog#Internal#FileAppenders#IFileAppenderFactory#Open(System.String,NLog.Internal.FileAppenders.ICreateFileParameters)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.Internal.FileAppenders.RetryingMultiProcessFileAppender">
            <summary>
            Multi-process and multi-host file appender which attempts
            to get exclusive write access and retries if it's not available.
            </summary>
        </member>
        <member name="M:NLog.Internal.FileAppenders.RetryingMultiProcessFileAppender.#ctor(System.String,NLog.Internal.FileAppenders.ICreateFileParameters)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Internal.FileAppenders.RetryingMultiProcessFileAppender" /> class.
            </summary>
            <param name="fileName">Name of the file.</param>
            <param name="parameters">The parameters.</param>
        </member>
        <member name="M:NLog.Internal.FileAppenders.RetryingMultiProcessFileAppender.Write(System.Byte[],System.Int32,System.Int32)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Internal.FileAppenders.RetryingMultiProcessFileAppender.Flush">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Internal.FileAppenders.RetryingMultiProcessFileAppender.Close">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Internal.FileAppenders.RetryingMultiProcessFileAppender.GetFileCreationTimeUtc">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Internal.FileAppenders.RetryingMultiProcessFileAppender.GetFileLength">
            <inheritdoc/>
        </member>
        <member name="T:NLog.Internal.FileAppenders.RetryingMultiProcessFileAppender.Factory">
            <summary>
            Factory class.
            </summary>
        </member>
        <member name="M:NLog.Internal.FileAppenders.RetryingMultiProcessFileAppender.Factory.NLog#Internal#FileAppenders#IFileAppenderFactory#Open(System.String,NLog.Internal.FileAppenders.ICreateFileParameters)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.Internal.FileAppenders.SingleProcessFileAppender">
            <summary>
            Optimized single-process file appender which keeps the file open for exclusive write.
            </summary>
        </member>
        <member name="M:NLog.Internal.FileAppenders.SingleProcessFileAppender.#ctor(System.String,NLog.Internal.FileAppenders.ICreateFileParameters)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Internal.FileAppenders.SingleProcessFileAppender" /> class.
            </summary>
            <param name="fileName">Name of the file.</param>
            <param name="parameters">The parameters.</param>
        </member>
        <member name="M:NLog.Internal.FileAppenders.SingleProcessFileAppender.Write(System.Byte[],System.Int32,System.Int32)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Internal.FileAppenders.SingleProcessFileAppender.Flush">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Internal.FileAppenders.SingleProcessFileAppender.Close">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Internal.FileAppenders.SingleProcessFileAppender.GetFileCreationTimeUtc">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Internal.FileAppenders.SingleProcessFileAppender.GetFileLength">
            <inheritdoc/>
        </member>
        <member name="T:NLog.Internal.FileAppenders.SingleProcessFileAppender.Factory">
            <summary>
            Factory class.
            </summary>
        </member>
        <member name="M:NLog.Internal.FileAppenders.SingleProcessFileAppender.Factory.NLog#Internal#FileAppenders#IFileAppenderFactory#Open(System.String,NLog.Internal.FileAppenders.ICreateFileParameters)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.Internal.FileAppenders.WindowsMultiProcessFileAppender">
            <summary>
            Provides a multi process-safe atomic file append while
            keeping the files open.
            </summary>
        </member>
        <member name="M:NLog.Internal.FileAppenders.WindowsMultiProcessFileAppender.#ctor(System.String,NLog.Internal.FileAppenders.ICreateFileParameters)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Internal.FileAppenders.WindowsMultiProcessFileAppender" /> class.
            </summary>
            <param name="fileName">Name of the file.</param>
            <param name="parameters">The parameters.</param>
        </member>
        <member name="M:NLog.Internal.FileAppenders.WindowsMultiProcessFileAppender.CreateAppendOnlyFile(System.String)">
            <summary>
            Creates or opens a file in a special mode, so that writes are automatically
            as atomic writes at the file end.
            See also "UnixMultiProcessFileAppender" which does a similar job on *nix platforms.
            </summary>
            <param name="fileName">File to create or open</param>
        </member>
        <member name="M:NLog.Internal.FileAppenders.WindowsMultiProcessFileAppender.Write(System.Byte[],System.Int32,System.Int32)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Internal.FileAppenders.WindowsMultiProcessFileAppender.Close">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Internal.FileAppenders.WindowsMultiProcessFileAppender.Flush">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Internal.FileAppenders.WindowsMultiProcessFileAppender.GetFileCreationTimeUtc">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Internal.FileAppenders.WindowsMultiProcessFileAppender.GetFileLength">
            <inheritdoc/>
        </member>
        <member name="T:NLog.Internal.FileAppenders.WindowsMultiProcessFileAppender.Factory">
            <summary>
            Factory class.
            </summary>
        </member>
        <member name="M:NLog.Internal.FileAppenders.WindowsMultiProcessFileAppender.Factory.NLog#Internal#FileAppenders#IFileAppenderFactory#Open(System.String,NLog.Internal.FileAppenders.ICreateFileParameters)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.Internal.FilePathLayout">
            <summary>
            A layout that represents a filePath.
            </summary>
        </member>
        <member name="F:NLog.Internal.FilePathLayout.DirectorySeparatorChars">
            <summary>
            Cached directory separator char array to avoid memory allocation on each method call.
            </summary>
        </member>
        <member name="F:NLog.Internal.FilePathLayout.InvalidFileNameChars">
            <summary>
            Cached invalid file names char array to avoid memory allocation every time Path.GetInvalidFileNameChars() is called.
            </summary>
        </member>
        <member name="F:NLog.Internal.FilePathLayout._baseDir">
            <summary>
            not null when <see cref="F:NLog.Internal.FilePathLayout._filePathKind"/> == <c>false</c>
            </summary>
        </member>
        <member name="F:NLog.Internal.FilePathLayout._cleanedFixedResult">
            <summary>
            non null is fixed,
            </summary>
        </member>
        <member name="F:NLog.Internal.FilePathLayout._cachedPrevRawFileName">
            <summary>
            <see cref="F:NLog.Internal.FilePathLayout._cachedPrevRawFileName"/> is the cache-key, and when newly rendered filename matches the cache-key,
            then it reuses the cleaned cache-value <see cref="F:NLog.Internal.FilePathLayout._cachedPrevCleanFileName"/>.
            </summary>
        </member>
        <member name="F:NLog.Internal.FilePathLayout._cachedPrevCleanFileName">
            <summary>
            <see cref="F:NLog.Internal.FilePathLayout._cachedPrevCleanFileName"/> is the cache-value that is reused, when the newly rendered filename
            matches the cache-key <see cref="F:NLog.Internal.FilePathLayout._cachedPrevRawFileName"/>
            </summary>
        </member>
        <member name="M:NLog.Internal.FilePathLayout.#ctor(NLog.Layouts.Layout,System.Boolean,NLog.Targets.FilePathKind)">
            <summary>Initializes a new instance of the <see cref="T:NLog.Internal.FilePathLayout" /> class.</summary>
        </member>
        <member name="M:NLog.Internal.FilePathLayout.GetRenderedFileName(NLog.LogEventInfo,System.Text.StringBuilder)">
            <summary>
            Render the raw filename from Layout
            </summary>
            <param name="logEvent">The log event.</param>
            <param name="reusableBuilder">StringBuilder to minimize allocations [optional].</param>
            <returns>String representation of a layout.</returns>
        </member>
        <member name="M:NLog.Internal.FilePathLayout.GetCleanFileName(System.String)">
            <summary>
            Convert the raw filename to a correct filename
            </summary>
            <param name="rawFileName">The filename generated by Layout.</param>
            <returns>String representation of a correct filename.</returns>
        </member>
        <member name="M:NLog.Internal.FilePathLayout.DetectFilePathKind(NLog.Layouts.SimpleLayout)">
            <summary>
            Is this (templated/invalid) path an absolute, relative or unknown?
            </summary>
        </member>
        <member name="M:NLog.Internal.FormatHelper.ConvertToString(System.Object,System.IFormatProvider)">
            <summary>
            Convert object to string
            </summary>
            <param name="o">value</param>
            <param name="formatProvider">format for conversion.</param>
            <returns></returns>
            <remarks>
            If <paramref name="formatProvider"/> is <c>null</c> and <paramref name="o"/> isn't a <see cref="T:System.String"/> already, then the <see cref="T:NLog.LogFactory"/> will get a locked by <see cref="P:NLog.LogManager.Configuration"/>
            </remarks>
        </member>
        <member name="T:NLog.Internal.IConfigurationManager">
            <summary>
            Interface for the wrapper around System.Configuration.ConfigurationManager.
            </summary>
        </member>
        <member name="P:NLog.Internal.IConfigurationManager.AppSettings">
            <summary>
            Gets the wrapper around ConfigurationManager.AppSettings.
            </summary>
        </member>
        <member name="T:NLog.Internal.ILogMessageFormatter">
            <summary>
            Format a log message
            </summary>
        </member>
        <member name="P:NLog.Internal.ILogMessageFormatter.EnableMessageTemplateParser">
            <summary>
            Perform message template parsing and formatting of LogEvent messages (True = Always, False = Never, Null = Auto Detect)
            </summary>
        </member>
        <member name="M:NLog.Internal.ILogMessageFormatter.FormatMessage(NLog.LogEventInfo)">
            <summary>
            Format the message and return
            </summary>
            <param name="logEvent">LogEvent with message to be formatted</param>
            <returns>formatted message</returns>
        </member>
        <member name="M:NLog.Internal.ILogMessageFormatter.HasProperties(NLog.LogEventInfo)">
            <summary>
            Has the logevent properties?
            </summary>
            <param name="logEvent">LogEvent with message to be formatted</param>
            <returns>False when logevent has no properties to be extracted</returns>
        </member>
        <member name="M:NLog.Internal.ILogMessageFormatter.AppendFormattedMessage(NLog.LogEventInfo,System.Text.StringBuilder)">
            <summary>
            Appends the logevent message to the provided StringBuilder
            </summary>
            <param name="logEvent">LogEvent with message to be formatted</param>
            <param name="builder">The <see cref="T:System.Text.StringBuilder"/> to append the formatted message.</param>
        </member>
        <member name="T:NLog.Internal.INetworkInterfaceRetriever">
            <summary>
            Retrieve network interfaces
            </summary>
        </member>
        <member name="P:NLog.Internal.INetworkInterfaceRetriever.AllNetworkInterfaces">
            <summary>
            Retrieve network interfaces
            </summary>
        </member>
        <member name="T:NLog.Internal.IRawValue">
            <summary>
            Get the Raw, unformatted value without stringify
            </summary>
            <remarks>
            Implementors must has the  [ThreadAgnostic] attribute
            </remarks>
        </member>
        <member name="M:NLog.Internal.IRawValue.TryGetRawValue(NLog.LogEventInfo,System.Object@)">
            <summary>
            Get the raw value
            </summary>
            <param name="logEvent"></param>
            <param name="value">The value</param>
            <returns>RawValue supported?</returns>
        </member>
        <member name="T:NLog.Internal.IRenderable">
            <summary>
            Interface implemented by layouts and layout renderers.
            </summary>
        </member>
        <member name="M:NLog.Internal.IRenderable.Render(NLog.LogEventInfo)">
            <summary>
            Renders the value of layout or layout renderer in the context of the specified log event.
            </summary>
            <param name="logEvent">The log event.</param>
            <returns>String representation of a layout.</returns>
        </member>
        <member name="T:NLog.Internal.ISmtpClient">
            <summary>
            Supports mocking of SMTP Client code.
            </summary>
        </member>
        <member name="P:NLog.Internal.ISmtpClient.DeliveryMethod">
            <summary>
            Specifies how outgoing email messages will be handled.
            </summary>
        </member>
        <member name="P:NLog.Internal.ISmtpClient.Host">
            <summary>
            Gets or sets the name or IP address of the host used for SMTP transactions.
            </summary>
        </member>
        <member name="P:NLog.Internal.ISmtpClient.Port">
            <summary>
            Gets or sets the port used for SMTP transactions.
            </summary>
        </member>
        <member name="P:NLog.Internal.ISmtpClient.Timeout">
            <summary>
            Gets or sets a value that specifies the amount of time after which a synchronous <see cref="M:NLog.Internal.ISmtpClient.Send(System.Net.Mail.MailMessage)">Send</see> call times out.
            </summary>
        </member>
        <member name="P:NLog.Internal.ISmtpClient.Credentials">
            <summary>
            Gets or sets the credentials used to authenticate the sender.
            </summary>
        </member>
        <member name="M:NLog.Internal.ISmtpClient.Send(System.Net.Mail.MailMessage)">
            <summary>
            Sends an e-mail message to an SMTP server for delivery. These methods block while the message is being transmitted.
            </summary>
            <param name="msg">
              <typeparam>System.Net.Mail.MailMessage
                <name>MailMessage</name>
            </typeparam> A <see cref="T:System.Net.Mail.MailMessage">MailMessage</see> that contains the message to send.</param>
        </member>
        <member name="P:NLog.Internal.ISmtpClient.PickupDirectoryLocation">
            <summary>
            Gets or sets the folder where applications save mail messages to be processed by the local SMTP server.
            </summary>
        </member>
        <member name="T:NLog.Internal.IStringValueRenderer">
            <summary>
            Supports rendering as string value with limited or no allocations (preferred)
            </summary>
            <remarks>
            Implementors must not have the [AppDomainFixedOutput] attribute
            </remarks>
        </member>
        <member name="M:NLog.Internal.IStringValueRenderer.GetFormattedString(NLog.LogEventInfo)">
            <summary>
            Renders the value of layout renderer in the context of the specified log event
            </summary>
            <param name="logEvent"></param>
            <returns>null if not possible or unknown</returns>
        </member>
        <member name="T:NLog.Internal.ISupportsInitialize">
            <summary>
            Supports object initialization and termination.
            </summary>
        </member>
        <member name="M:NLog.Internal.ISupportsInitialize.Initialize(NLog.Config.LoggingConfiguration)">
            <summary>
            Initializes this instance.
            </summary>
            <param name="configuration">The configuration.</param>
        </member>
        <member name="M:NLog.Internal.ISupportsInitialize.Close">
            <summary>
            Closes this instance.
            </summary>
        </member>
        <member name="P:NLog.Internal.LogMessageStringFormatter.MessageFormatter">
            <summary>
            The MessageFormatter delegate
            </summary>
        </member>
        <member name="F:NLog.Internal.LogMessageTemplateFormatter._forceTemplateRenderer">
            <summary>
            When true: Do not fallback to StringBuilder.Format for positional templates
            </summary>
        </member>
        <member name="M:NLog.Internal.LogMessageTemplateFormatter.#ctor(System.IServiceProvider,System.Boolean,System.Boolean)">
            <summary>
            New formatter
            </summary>
            <param name="serviceProvider"></param>
            <param name="forceTemplateRenderer">When true: Do not fallback to StringBuilder.Format for positional templates</param>
            <param name="singleTargetOnly"></param>
        </member>
        <member name="P:NLog.Internal.LogMessageTemplateFormatter.MessageFormatter">
            <summary>
            The MessageFormatter delegate
            </summary>
        </member>
        <member name="M:NLog.Internal.LogMessageTemplateFormatter.HasProperties(NLog.LogEventInfo)">
            <inheritDoc/>
        </member>
        <member name="M:NLog.Internal.LogMessageTemplateFormatter.Render(System.String,System.IFormatProvider,System.Object[],System.Text.StringBuilder,System.Collections.Generic.IList{NLog.MessageTemplates.MessageTemplateParameter}@)">
            <summary>
            Render a template to a string.
            </summary>
            <param name="template">The template.</param>
            <param name="formatProvider">Culture.</param>
            <param name="parameters">Parameters for the holes.</param>
            <param name="sb">The String Builder destination.</param>
            <param name="messageTemplateParameters">Parameters for the holes.</param>
        </member>
        <member name="T:NLog.Internal.MruCache`2">
            <summary>
            Most-Recently-Used-Cache, that discards less frequently used items on overflow
            </summary>
        </member>
        <member name="M:NLog.Internal.MruCache`2.#ctor(System.Int32)">
            <summary>
            Constructor
            </summary>
            <param name="maxCapacity">Maximum number of items the cache will hold before discarding.</param>
        </member>
        <member name="M:NLog.Internal.MruCache`2.TryAddValue(`0,`1)">
            <summary>
            Attempt to insert item into cache.
            </summary>
            <param name="key">Key of the item to be inserted in the cache.</param>
            <param name="value">Value of the item to be inserted in the cache.</param>
            <returns><c>true</c> when the key does not already exist in the cache, <c>false</c> otherwise.</returns>
        </member>
        <member name="M:NLog.Internal.MruCache`2.TryGetValue(`0,`1@)">
            <summary>
            Lookup existing item in cache.
            </summary>
            <param name="key">Key of the item to be searched in the cache.</param>
            <param name="value">Output value of the item found in the cache.</param>
            <returns><c>True</c> when the key is found in the cache, <c>false</c> otherwise.</returns>
        </member>
        <member name="T:NLog.Internal.MultiFileWatcher">
            <summary>
            Watches multiple files at the same time and raises an event whenever
            a single change is detected in any of those files.
            </summary>
        </member>
        <member name="P:NLog.Internal.MultiFileWatcher.NotifyFilters">
            <summary>
            The types of changes to watch for.
            </summary>
        </member>
        <member name="E:NLog.Internal.MultiFileWatcher.FileChanged">
            <summary>
            Occurs when a change is detected in one of the monitored files.
            </summary>
        </member>
        <member name="M:NLog.Internal.MultiFileWatcher.Dispose">
            <summary>
            Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
            </summary>
        </member>
        <member name="M:NLog.Internal.MultiFileWatcher.StopWatching">
            <summary>
            Stops watching all files.
            </summary>
        </member>
        <member name="M:NLog.Internal.MultiFileWatcher.StopWatching(System.String)">
            <summary>
            Stops watching the specified file.
            </summary>
            <param name="fileName"></param>
        </member>
        <member name="M:NLog.Internal.MultiFileWatcher.Watch(System.Collections.Generic.IEnumerable{System.String})">
            <summary>
            Watches the specified files for changes.
            </summary>
            <param name="fileNames">The file names.</param>
        </member>
        <member name="T:NLog.Internal.MutexDetector">
            <summary>
            Detects the platform the NLog is running on.
            </summary>
        </member>
        <member name="P:NLog.Internal.MutexDetector.SupportsSharableMutex">
            <summary>
            Gets a value indicating whether current runtime supports use of mutex
            </summary>
        </member>
        <member name="M:NLog.Internal.MutexDetector.ResolveSupportsSharableMutex">
            <summary>
            Will creating a mutex succeed runtime?
            </summary>
        </member>
        <member name="T:NLog.Internal.MySmtpClient">
            <summary>
            Supports mocking of SMTP Client code.
            </summary>
            <remarks>
            Disabled Error CS0618  'SmtpClient' is obsolete: 'SmtpClient and its network of types are poorly designed,
             we strongly recommend you use https://github.com/jstedfast/MailKit and https://github.com/jstedfast/MimeKit instead'
            </remarks>
        </member>
        <member name="T:NLog.Internal.NetworkInterfaceRetriever">
            <summary>
            Retrieve network interfaces
            </summary>
        </member>
        <member name="P:NLog.Internal.NetworkInterfaceRetriever.AllNetworkInterfaces">
            <summary>
            Retrieve network interfaces
            </summary>
        </member>
        <member name="T:NLog.Internal.NetworkSenders.HttpNetworkSender">
            <summary>
            Network sender which uses HTTP or HTTPS POST.
            </summary>
        </member>
        <member name="M:NLog.Internal.NetworkSenders.HttpNetworkSender.#ctor(System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Internal.NetworkSenders.HttpNetworkSender"/> class.
            </summary>
            <param name="url">The network URL.</param>
        </member>
        <member name="T:NLog.Internal.NetworkSenders.INetworkSenderFactory">
            <summary>
            Creates instances of <see cref="T:NLog.Internal.NetworkSenders.NetworkSender"/> objects for given URLs.
            </summary>
        </member>
        <member name="M:NLog.Internal.NetworkSenders.INetworkSenderFactory.Create(System.String,System.Int32,NLog.Targets.NetworkTargetQueueOverflowAction,System.Int32,System.Security.Authentication.SslProtocols,System.TimeSpan,System.TimeSpan)">
            <summary>
            Creates a new instance of the network sender based on a network URL.
            </summary>
            <param name="url">URL that determines the network sender to be created.</param>
            <param name="maxQueueSize">The maximum queue size.</param>
            <param name="onQueueOverflow">The overflow action when reaching maximum queue size.</param>
            <param name="maxMessageSize">The maximum message size.</param>
            <param name="sslProtocols">SSL protocols for TCP</param>
            <param name="keepAliveTime">KeepAliveTime for TCP</param>
            <param name="sendTimeout">SendTimeout for TCP</param>
            <returns>
            A newly created network sender.
            </returns>
        </member>
        <member name="T:NLog.Internal.NetworkSenders.ISocket">
            <summary>
            Interface for mocking socket calls.
            </summary>
        </member>
        <member name="T:NLog.Internal.NetworkSenders.NetworkSender">
            <summary>
            A base class for all network senders. Supports one-way sending of messages
            over various protocols.
            </summary>
        </member>
        <member name="M:NLog.Internal.NetworkSenders.NetworkSender.#ctor(System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Internal.NetworkSenders.NetworkSender" /> class.
            </summary>
            <param name="url">The network URL.</param>
        </member>
        <member name="P:NLog.Internal.NetworkSenders.NetworkSender.Address">
            <summary>
            Gets the address of the network endpoint.
            </summary>
        </member>
        <member name="P:NLog.Internal.NetworkSenders.NetworkSender.LastSendTime">
            <summary>
            Gets the last send time.
            </summary>
        </member>
        <member name="M:NLog.Internal.NetworkSenders.NetworkSender.Initialize">
            <summary>
            Initializes this network sender.
            </summary>
        </member>
        <member name="M:NLog.Internal.NetworkSenders.NetworkSender.Close(NLog.Common.AsyncContinuation)">
            <summary>
            Closes the sender and releases any unmanaged resources.
            </summary>
            <param name="continuation">The continuation.</param>
        </member>
        <member name="M:NLog.Internal.NetworkSenders.NetworkSender.FlushAsync(NLog.Common.AsyncContinuation)">
            <summary>
            Flushes any pending messages and invokes the <paramref name="continuation"/> on completion.
            </summary>
            <param name="continuation">The continuation.</param>
        </member>
        <member name="M:NLog.Internal.NetworkSenders.NetworkSender.Send(System.Byte[],System.Int32,System.Int32,NLog.Common.AsyncContinuation)">
            <summary>
            Send the given text over the specified protocol.
            </summary>
            <param name="bytes">Bytes to be sent.</param>
            <param name="offset">Offset in buffer.</param>
            <param name="length">Number of bytes to send.</param>
            <param name="asyncContinuation">The asynchronous continuation.</param>
        </member>
        <member name="M:NLog.Internal.NetworkSenders.NetworkSender.Dispose">
            <summary>
            Closes the sender and releases any unmanaged resources.
            </summary>
        </member>
        <member name="M:NLog.Internal.NetworkSenders.NetworkSender.DoInitialize">
            <summary>
            Initializes resources for the protocol specific implementation.
            </summary>
        </member>
        <member name="M:NLog.Internal.NetworkSenders.NetworkSender.DoClose(NLog.Common.AsyncContinuation)">
            <summary>
            Closes resources for the protocol specific implementation.
            </summary>
            <param name="continuation">The continuation.</param>
        </member>
        <member name="M:NLog.Internal.NetworkSenders.NetworkSender.DoFlush(NLog.Common.AsyncContinuation)">
            <summary>
            Performs the flush and invokes the <paramref name="continuation"/> on completion.
            </summary>
            <param name="continuation">The continuation.</param>
        </member>
        <member name="M:NLog.Internal.NetworkSenders.NetworkSender.DoSend(System.Byte[],System.Int32,System.Int32,NLog.Common.AsyncContinuation)">
            <summary>
            Sends the payload using the protocol specific implementation.
            </summary>
            <param name="bytes">The bytes to be sent.</param>
            <param name="offset">Offset in buffer.</param>
            <param name="length">Number of bytes to send.</param>
            <param name="asyncContinuation">The async continuation to be invoked after the buffer has been sent.</param>
        </member>
        <member name="M:NLog.Internal.NetworkSenders.NetworkSender.ResolveIpAddress(System.Uri,System.Net.Sockets.AddressFamily)">
            <summary>
            Parses the URI into an IP address.
            </summary>
            <param name="uri">The URI to parse.</param>
            <param name="addressFamily">The address family.</param>
            <returns>Parsed endpoint.</returns>
        </member>
        <member name="T:NLog.Internal.NetworkSenders.NetworkSenderFactory">
            <summary>
            Default implementation of <see cref="T:NLog.Internal.NetworkSenders.INetworkSenderFactory"/>.
            </summary>
        </member>
        <member name="M:NLog.Internal.NetworkSenders.NetworkSenderFactory.Create(System.String,System.Int32,NLog.Targets.NetworkTargetQueueOverflowAction,System.Int32,System.Security.Authentication.SslProtocols,System.TimeSpan,System.TimeSpan)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.Internal.NetworkSenders.QueuedNetworkSender">
            <summary>
            A base class for network senders that can block or send out-of-order
            </summary>
        </member>
        <member name="M:NLog.Internal.NetworkSenders.QueuedNetworkSender.#ctor(System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Internal.NetworkSenders.QueuedNetworkSender"/> class.
            </summary>
            <param name="url">URL. Must start with tcp://.</param>
        </member>
        <member name="T:NLog.Internal.NetworkSenders.SocketProxy">
            <summary>
            Socket proxy for mocking Socket code.
            </summary>
        </member>
        <member name="M:NLog.Internal.NetworkSenders.SocketProxy.#ctor(System.Net.Sockets.AddressFamily,System.Net.Sockets.SocketType,System.Net.Sockets.ProtocolType)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Internal.NetworkSenders.SocketProxy"/> class.
            </summary>
            <param name="addressFamily">The address family.</param>
            <param name="socketType">Type of the socket.</param>
            <param name="protocolType">Type of the protocol.</param>
        </member>
        <member name="P:NLog.Internal.NetworkSenders.SocketProxy.UnderlyingSocket">
            <summary>
            Gets underlying socket instance.
            </summary>
        </member>
        <member name="M:NLog.Internal.NetworkSenders.SocketProxy.Close">
            <summary>
            Closes the wrapped socket.
            </summary>
        </member>
        <member name="M:NLog.Internal.NetworkSenders.SocketProxy.ConnectAsync(System.Net.Sockets.SocketAsyncEventArgs)">
            <summary>
            Invokes ConnectAsync method on the wrapped socket.
            </summary>
            <param name="args">The <see cref="T:System.Net.Sockets.SocketAsyncEventArgs"/> instance containing the event data.</param>
            <returns>Result of original method.</returns>
        </member>
        <member name="M:NLog.Internal.NetworkSenders.SocketProxy.SendAsync(System.Net.Sockets.SocketAsyncEventArgs)">
            <summary>
            Invokes SendAsync method on the wrapped socket.
            </summary>
            <param name="args">The <see cref="T:System.Net.Sockets.SocketAsyncEventArgs"/> instance containing the event data.</param>
            <returns>Result of original method.</returns>
        </member>
        <member name="M:NLog.Internal.NetworkSenders.SocketProxy.SendToAsync(System.Net.Sockets.SocketAsyncEventArgs)">
            <summary>
            Invokes SendToAsync method on the wrapped socket.
            </summary>
            <param name="args">The <see cref="T:System.Net.Sockets.SocketAsyncEventArgs"/> instance containing the event data.</param>
            <returns>Result of original method.</returns>
        </member>
        <member name="M:NLog.Internal.NetworkSenders.SocketProxy.Dispose">
            <summary>
            Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
            </summary>
        </member>
        <member name="T:NLog.Internal.NetworkSenders.TcpNetworkSender">
            <summary>
            Sends messages over a TCP network connection.
            </summary>
        </member>
        <member name="M:NLog.Internal.NetworkSenders.TcpNetworkSender.#ctor(System.String,System.Net.Sockets.AddressFamily)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Internal.NetworkSenders.TcpNetworkSender"/> class.
            </summary>
            <param name="url">URL. Must start with tcp://.</param>
            <param name="addressFamily">The address family.</param>
        </member>
        <member name="M:NLog.Internal.NetworkSenders.TcpNetworkSender.CreateSocket(System.String,System.Net.Sockets.AddressFamily,System.Net.Sockets.SocketType,System.Net.Sockets.ProtocolType,System.TimeSpan)">
            <summary>
            Creates the socket with given parameters.
            </summary>
            <param name="host">The host address.</param>
            <param name="addressFamily">The address family.</param>
            <param name="socketType">Type of the socket.</param>
            <param name="protocolType">Type of the protocol.</param>
            <param name="sendTimeout">Socket SendTimeout.</param>
            <returns>Instance of <see cref="T:NLog.Internal.NetworkSenders.ISocket" /> which represents the socket.</returns>
        </member>
        <member name="T:NLog.Internal.NetworkSenders.TcpNetworkSender.MySocketAsyncEventArgs">
            <summary>
            Facilitates mocking of <see cref="T:System.Net.Sockets.SocketAsyncEventArgs"/> class.
            </summary>
        </member>
        <member name="M:NLog.Internal.NetworkSenders.TcpNetworkSender.MySocketAsyncEventArgs.RaiseCompleted">
            <summary>
            Raises the Completed event.
            </summary>
        </member>
        <member name="T:NLog.Internal.NetworkSenders.UdpNetworkSender">
            <summary>
            Sends messages over the network as UDP datagrams.
            </summary>
        </member>
        <member name="M:NLog.Internal.NetworkSenders.UdpNetworkSender.#ctor(System.String,System.Net.Sockets.AddressFamily)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Internal.NetworkSenders.UdpNetworkSender"/> class.
            </summary>
            <param name="url">URL. Must start with udp://.</param>
            <param name="addressFamily">The address family.</param>
        </member>
        <member name="M:NLog.Internal.NetworkSenders.UdpNetworkSender.CreateSocket(System.Net.IPAddress)">
            <summary>
            Creates the socket.
            </summary>
            <param name="ipAddress">The IP address.</param>
            <returns>Implementation of <see cref="T:NLog.Internal.NetworkSenders.ISocket"/> to use.</returns>
        </member>
        <member name="T:NLog.Internal.ObjectGraphScanner">
            <summary>
            Scans (breadth-first) the object graph following all the edges whose are
            instances have <see cref="T:NLog.Config.NLogConfigurationItemAttribute"/> attached and returns
            all objects implementing a specified interfaces.
            </summary>
        </member>
        <member name="M:NLog.Internal.ObjectGraphScanner.FindReachableObjects``1(NLog.Config.ConfigurationItemFactory,System.Boolean,System.Object[])">
            <summary>
            Finds the objects which have attached <see cref="T:NLog.Config.NLogConfigurationItemAttribute"/> which are reachable
            from any of the given root objects when traversing the object graph over public properties.
            </summary>
            <typeparam name="T">Type of the objects to return.</typeparam>
            <param name="configFactory">Configuration Reflection Helper</param>
            <param name="aggressiveSearch">Also search the properties of the wanted objects.</param>
            <param name="rootObjects">The root objects.</param>
            <returns>Ordered list of objects implementing T.</returns>
        </member>
        <member name="P:NLog.Internal.ObjectPropertyPath.Value">
            <summary>
            Object Path to check
            </summary>
        </member>
        <member name="T:NLog.Internal.ObjectReflectionCache">
            <summary>
            Converts object into a List of property-names and -values using reflection
            </summary>
        </member>
        <member name="M:NLog.Internal.ObjectReflectionCache.TryGetObjectProperty(System.Object,System.String[],System.Object@)">
            <summary>
            Try get value from <paramref name="value"/>, using <paramref name="objectPath"/>, and set into <paramref name="foundValue"/>
            </summary>
        </member>
        <member name="M:NLog.Internal.ObjectReflectionCache.ObjectPropertyList.TryFastLookupPropertyValue(System.String,NLog.Internal.ObjectReflectionCache.ObjectPropertyList.PropertyValue@)">
            <summary>
            Scans properties for name (Skips string-compare and value-lookup until finding match)
            </summary>
        </member>
        <member name="M:NLog.Internal.ObjectReflectionCache.ObjectPropertyList.TrySlowLookupPropertyValue(System.String,NLog.Internal.ObjectReflectionCache.ObjectPropertyList.PropertyValue@)">
            <summary>
            Scans properties for name (Skips property value lookup until finding match)
            </summary>
        </member>
        <member name="M:NLog.Internal.ObjectReflectionCache.ObjectPropertyList.TryListLookupPropertyValue(System.String,NLog.Internal.ObjectReflectionCache.ObjectPropertyList.PropertyValue@)">
            <summary>
            Scans properties for name
            </summary>
        </member>
        <member name="T:NLog.Internal.ObjectReflectionCache.GetBinderAdapter">
            <summary>
            Binder for retrieving value of <see cref="T:System.Dynamic.DynamicObject"/>
            </summary>
        </member>
        <member name="M:NLog.Internal.ObjectReflectionCache.GetBinderAdapter.FallbackGetMember(System.Dynamic.DynamicMetaObject,System.Dynamic.DynamicMetaObject)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Internal.PathHelpers.CombinePaths(System.String,System.String,System.String)">
            <summary>
            Combine paths
            </summary>
            <param name="path">basepath, not null</param>
            <param name="dir">optional dir</param>
            <param name="file">optional file</param>
            <returns></returns>
        </member>
        <member name="F:NLog.Internal.PathHelpers.DirectorySeparatorChars">
            <summary>
            Cached directory separator char array to avoid memory allocation on each method call.
            </summary>
        </member>
        <member name="M:NLog.Internal.PathHelpers.TrimDirectorySeparators(System.String)">
            <summary>
            Trims directory separators from the path
            </summary>
            <param name="path">path, could be null</param>
            <returns>never null</returns>
        </member>
        <member name="T:NLog.Internal.PlatformDetector">
            <summary>
            Detects the platform the NLog is running on.
            </summary>
        </member>
        <member name="P:NLog.Internal.PlatformDetector.CurrentOS">
            <summary>
            Gets the current runtime OS.
            </summary>
        </member>
        <member name="P:NLog.Internal.PlatformDetector.IsWin32">
            <summary>
            Gets a value indicating whether current OS is Win32-based (desktop or mobile).
            </summary>
        </member>
        <member name="P:NLog.Internal.PlatformDetector.IsUnix">
            <summary>
            Gets a value indicating whether current OS is Unix-based.
            </summary>
        </member>
        <member name="P:NLog.Internal.PlatformDetector.IsMono">
            <summary>
            Gets a value indicating whether current runtime is Mono-based
            </summary>
        </member>
        <member name="T:NLog.Internal.PropertiesDictionary">
             <summary>
             Dictionary that combines the standard <see cref="P:NLog.LogEventInfo.Properties" /> with the
             MessageTemplate-properties extracted from the <see cref="P:NLog.LogEventInfo.Message" />.
            
             The <see cref="P:NLog.Internal.PropertiesDictionary.MessageProperties" /> are returned as the first items
             in the collection, and in positional order.
             </summary>
        </member>
        <member name="F:NLog.Internal.PropertiesDictionary.PropertyValue.Value">
            <summary>
            Value of the property
            </summary>
        </member>
        <member name="F:NLog.Internal.PropertiesDictionary.PropertyValue.IsMessageProperty">
            <summary>
            Has property been captured from message-template ?
            </summary>
        </member>
        <member name="F:NLog.Internal.PropertiesDictionary._eventProperties">
            <summary>
            The properties of the logEvent
            </summary>
        </member>
        <member name="F:NLog.Internal.PropertiesDictionary._messageProperties">
            <summary>
            The properties extracted from the message-template
            </summary>
        </member>
        <member name="M:NLog.Internal.PropertiesDictionary.#ctor(System.Collections.Generic.IList{NLog.MessageTemplates.MessageTemplateParameter})">
            <summary>
            Wraps the list of message-template-parameters as IDictionary-interface
            </summary>
            <param name="messageParameters">Message-template-parameters</param>
        </member>
        <member name="M:NLog.Internal.PropertiesDictionary.#ctor(System.Collections.Generic.IReadOnlyList{System.Collections.Generic.KeyValuePair{System.Object,System.Object}})">
            <summary>
            Transforms the list of event-properties into IDictionary-interface
            </summary>
            <param name="eventProperties">Message-template-parameters</param>
        </member>
        <member name="P:NLog.Internal.PropertiesDictionary.Item(System.Object)">
            <inheritDoc/>
        </member>
        <member name="P:NLog.Internal.PropertiesDictionary.Keys">
            <inheritDoc/>
        </member>
        <member name="P:NLog.Internal.PropertiesDictionary.Values">
            <inheritDoc/>
        </member>
        <member name="P:NLog.Internal.PropertiesDictionary.Count">
            <inheritDoc/>
        </member>
        <member name="P:NLog.Internal.PropertiesDictionary.IsReadOnly">
            <inheritDoc/>
        </member>
        <member name="M:NLog.Internal.PropertiesDictionary.Add(System.Object,System.Object)">
            <inheritDoc/>
        </member>
        <member name="M:NLog.Internal.PropertiesDictionary.Add(System.Collections.Generic.KeyValuePair{System.Object,System.Object})">
            <inheritDoc/>
        </member>
        <member name="M:NLog.Internal.PropertiesDictionary.Clear">
            <inheritDoc/>
        </member>
        <member name="M:NLog.Internal.PropertiesDictionary.Contains(System.Collections.Generic.KeyValuePair{System.Object,System.Object})">
            <inheritDoc/>
        </member>
        <member name="M:NLog.Internal.PropertiesDictionary.ContainsKey(System.Object)">
            <inheritDoc/>
        </member>
        <member name="M:NLog.Internal.PropertiesDictionary.CopyTo(System.Collections.Generic.KeyValuePair{System.Object,System.Object}[],System.Int32)">
            <inheritDoc/>
        </member>
        <member name="M:NLog.Internal.PropertiesDictionary.GetEnumerator">
            <inheritDoc/>
        </member>
        <member name="M:NLog.Internal.PropertiesDictionary.System#Collections#IEnumerable#GetEnumerator">
            <inheritDoc/>
        </member>
        <member name="M:NLog.Internal.PropertiesDictionary.Remove(System.Object)">
            <inheritDoc/>
        </member>
        <member name="M:NLog.Internal.PropertiesDictionary.Remove(System.Collections.Generic.KeyValuePair{System.Object,System.Object})">
            <inheritDoc/>
        </member>
        <member name="M:NLog.Internal.PropertiesDictionary.TryGetValue(System.Object,System.Object@)">
            <inheritDoc/>
        </member>
        <member name="M:NLog.Internal.PropertiesDictionary.VerifyUniqueMessageTemplateParametersFast(System.Collections.Generic.IList{NLog.MessageTemplates.MessageTemplateParameter})">
            <summary>
            Check if the message-template-parameters can be used directly without allocating a dictionary
            </summary>
            <param name="parameterList">Message-template-parameters</param>
            <returns>Are all parameter names unique (true / false)</returns>
        </member>
        <member name="M:NLog.Internal.PropertiesDictionary.InsertMessagePropertiesIntoEmptyDictionary(System.Collections.Generic.IList{NLog.MessageTemplates.MessageTemplateParameter},System.Collections.Generic.Dictionary{System.Object,NLog.Internal.PropertiesDictionary.PropertyValue})">
            <summary>
            Attempt to insert the message-template-parameters into an empty dictionary
            </summary>
            <param name="messageProperties">Message-template-parameters</param>
            <param name="eventProperties">The dictionary that initially contains no message-template-parameters</param>
        </member>
        <member name="P:NLog.Internal.PropertiesDictionary.DictionaryCollection.Count">
            <inheritDoc/>
        </member>
        <member name="P:NLog.Internal.PropertiesDictionary.DictionaryCollection.IsReadOnly">
            <inheritDoc/>
        </member>
        <member name="M:NLog.Internal.PropertiesDictionary.DictionaryCollection.Add(System.Object)">
            <summary>Will always throw, as collection is readonly</summary>
        </member>
        <member name="M:NLog.Internal.PropertiesDictionary.DictionaryCollection.Clear">
            <summary>Will always throw, as collection is readonly</summary>
        </member>
        <member name="M:NLog.Internal.PropertiesDictionary.DictionaryCollection.Remove(System.Object)">
            <summary>Will always throw, as collection is readonly</summary>
        </member>
        <member name="M:NLog.Internal.PropertiesDictionary.DictionaryCollection.Contains(System.Object)">
            <inheritDoc/>
        </member>
        <member name="M:NLog.Internal.PropertiesDictionary.DictionaryCollection.CopyTo(System.Object[],System.Int32)">
            <inheritDoc/>
        </member>
        <member name="M:NLog.Internal.PropertiesDictionary.DictionaryCollection.GetEnumerator">
            <inheritDoc/>
        </member>
        <member name="M:NLog.Internal.PropertiesDictionary.DictionaryCollection.System#Collections#IEnumerable#GetEnumerator">
            <inheritDoc/>
        </member>
        <member name="P:NLog.Internal.PropertiesDictionary.DictionaryCollection.DictionaryCollectionEnumerator.Current">
            <inheritDoc/>
        </member>
        <member name="T:NLog.Internal.PropertiesDictionary.IgnoreCasePropertyKey">
            <summary>
            Special property-key for lookup without being case-sensitive
            </summary>
        </member>
        <member name="T:NLog.Internal.PropertiesDictionary.PropertyKeyComparer">
            <summary>
            Property-Key equality-comparer that uses string-hashcode from OrdinalIgnoreCase
            Enables case-insensitive lookup using <see cref="T:NLog.Internal.PropertiesDictionary.IgnoreCasePropertyKey"/>
            </summary>
        </member>
        <member name="T:NLog.Internal.PropertyHelper">
            <summary>
            Reflection helpers for accessing properties.
            </summary>
        </member>
        <member name="M:NLog.Internal.PropertyHelper.TryGetPropertyInfo(NLog.Config.ConfigurationItemFactory,System.Object,System.String,System.Reflection.PropertyInfo@)">
            <summary>
            Get property info
            </summary>
            <param name="configFactory">Configuration Reflection Helper</param>
            <param name="obj">object which could have property <paramref name="propertyName"/></param>
            <param name="propertyName">property name on <paramref name="obj"/></param>
            <param name="result">result when success.</param>
            <returns>success.</returns>
        </member>
        <member name="M:NLog.Internal.PropertyHelper.TryFlatListConversion(System.Object,System.Reflection.PropertyInfo,System.String,NLog.Config.ConfigurationItemFactory,System.Object@)">
            <summary>
            Try parse of string to (Generic) list, comma separated.
            </summary>
            <remarks>
            If there is a comma in the value, then (single) quote the value. For single quotes, use the backslash as escape
            </remarks>
        </member>
        <member name="M:NLog.Internal.PropertyHelper.ExtractHashSetComparer(System.Object,System.Reflection.PropertyInfo)">
            <summary>
            Attempt to reuse the HashSet.Comparer from the original HashSet-object (Ex. StringComparer.OrdinalIgnoreCase)
            </summary>
        </member>
        <member name="T:NLog.Internal.ReflectionHelpers">
            <summary>
            Reflection helpers.
            </summary>
        </member>
        <member name="M:NLog.Internal.ReflectionHelpers.IsStaticClass(System.Type)">
            <summary>
            Is this a static class?
            </summary>
            <param name="type"></param>
            <returns></returns>
            <remarks>This is a work around, as Type doesn't have this property.
            From: https://stackoverflow.com/questions/1175888/determine-if-a-type-is-static
            </remarks>
        </member>
        <member name="T:NLog.Internal.ReflectionHelpers.LateBoundMethod">
            <summary>
            Optimized delegate for calling MethodInfo
            </summary>
            <param name="target">Object instance, use null for static methods.</param>
            <param name="arguments">Complete list of parameters that matches the method, including optional/default parameters.</param>
        </member>
        <member name="T:NLog.Internal.ReflectionHelpers.LateBoundConstructor">
            <summary>
            Optimized delegate for calling a constructor
            </summary>
            <param name="arguments">Complete list of parameters that matches the constructor, including optional/default parameters. Could be null for no parameters.</param>
        </member>
        <member name="M:NLog.Internal.ReflectionHelpers.CreateLateBoundMethod(System.Reflection.MethodInfo)">
            <summary>
            Creates an optimized delegate for calling the MethodInfo using Expression-Trees
            </summary>
            <param name="methodInfo">Method to optimize</param>
            <returns>Optimized delegate for invoking the MethodInfo</returns>
        </member>
        <member name="M:NLog.Internal.ReflectionHelpers.CreateLateBoundConstructor(System.Reflection.ConstructorInfo)">
            <summary>
            Creates an optimized delegate for calling the constructors using Expression-Trees
            </summary>
            <param name="constructor">Constructor to optimize</param>
            <returns>Optimized delegate for invoking the constructor</returns>
        </member>
        <member name="P:NLog.Internal.RegexHelper.CompileRegex">
            <summary>
            Compile the <see cref="P:NLog.Internal.RegexHelper.Regex"/>? This can improve the performance, but at the costs of more memory usage. If <c>false</c>, the Regex Cache is used.
            </summary>
        </member>
        <member name="P:NLog.Internal.RegexHelper.WholeWords">
            <summary>
            Gets or sets a value indicating whether to match whole words only.
            </summary>
        </member>
        <member name="P:NLog.Internal.RegexHelper.IgnoreCase">
            <summary>
            Gets or sets a value indicating whether to ignore case when comparing texts.
            </summary>
        </member>
        <member name="T:NLog.Internal.ReusableAsyncLogEventList">
            <summary>
            Controls a single allocated AsyncLogEventInfo-List for reuse (only one active user)
            </summary>
        </member>
        <member name="T:NLog.Internal.ReusableBufferCreator">
            <summary>
            Controls a single allocated char[]-buffer for reuse (only one active user)
            </summary>
        </member>
        <member name="T:NLog.Internal.ReusableBuilderCreator">
            <summary>
            Controls a single allocated StringBuilder for reuse (only one active user)
            </summary>
        </member>
        <member name="T:NLog.Internal.ReusableObjectCreator`1">
            <summary>
            Controls a single allocated object for reuse (only one active user)
            </summary>
        </member>
        <member name="M:NLog.Internal.ReusableObjectCreator`1.Allocate">
            <summary>
            Creates handle to the reusable char[]-buffer for active usage
            </summary>
            <returns>Handle to the reusable item, that can release it again</returns>
        </member>
        <member name="F:NLog.Internal.ReusableObjectCreator`1.LockOject.Result">
            <summary>
            Access the acquired reusable object
            </summary>
        </member>
        <member name="T:NLog.Internal.ReusableStreamCreator">
            <summary>
            Controls a single allocated MemoryStream for reuse (only one active user)
            </summary>
        </member>
        <member name="T:NLog.Internal.RuntimeOS">
            <summary>
            Supported operating systems.
            </summary>
            <remarks>
            If you add anything here, make sure to add the appropriate detection
            code to <see cref="T:NLog.Internal.PlatformDetector"/>
            </remarks>
        </member>
        <member name="F:NLog.Internal.RuntimeOS.Unknown">
            <summary>
            Unknown operating system.
            </summary>
        </member>
        <member name="F:NLog.Internal.RuntimeOS.Linux">
            <summary>
            Unix/Linux operating systems.
            </summary>
        </member>
        <member name="F:NLog.Internal.RuntimeOS.Windows9x">
            <summary>
            Desktop versions of Windows (95,98,ME).
            </summary>
        </member>
        <member name="F:NLog.Internal.RuntimeOS.WindowsNT">
            <summary>
            Windows NT, 2000, 2003 and future versions based on NT technology.
            </summary>
        </member>
        <member name="F:NLog.Internal.RuntimeOS.MacOSX">
            <summary>
            Macintosh Mac OSX
            </summary>
        </member>
        <member name="T:NLog.Internal.ScopeContextAsyncState">
            <summary>
            Immutable state that combines ScopeContext MDLC + NDLC for <see cref="T:System.Threading.AsyncLocal`1"/>
            </summary>
        </member>
        <member name="T:NLog.Internal.IScopeContextAsyncState">
            <summary>
            Immutable state that combines ScopeContext MDLC + NDLC for <see cref="T:System.Threading.AsyncLocal`1"/>
            </summary>
        </member>
        <member name="T:NLog.Internal.IScopeContextPropertiesAsyncState">
            <summary>
            Immutable state for ScopeContext Mapped Context (MDLC)
            </summary>
        </member>
        <member name="T:NLog.Internal.ScopedContextNestedAsyncState`1">
            <summary>
            Immutable state for ScopeContext Nested State (NDLC)
            </summary>
        </member>
        <member name="T:NLog.Internal.ScopeContextPropertyAsyncState`1">
            <summary>
            Immutable state for ScopeContext Single Property (MDLC)
            </summary>
        </member>
        <member name="T:NLog.Internal.ScopeContextPropertiesAsyncState`1">
            <summary>
            Immutable state for ScopeContext Multiple Properties (MDLC)
            </summary>
        </member>
        <member name="T:NLog.Internal.ScopeContextLegacyAsyncState">
            <summary>
            Immutable state for ScopeContext handling legacy MDLC + NDLC operations
            </summary>
        </member>
        <member name="P:NLog.Internal.SetupConfigurationLoggingRuleBuilder.LoggingRule">
            <inheritdoc/>
        </member>
        <member name="P:NLog.Internal.SetupConfigurationLoggingRuleBuilder.Configuration">
            <inheritdoc/>
        </member>
        <member name="P:NLog.Internal.SetupConfigurationLoggingRuleBuilder.LogFactory">
            <inheritdoc/>
        </member>
        <member name="P:NLog.Internal.SetupConfigurationLoggingRuleBuilder.Targets">
            <summary>
            Collection of targets that should be written to
            </summary>
        </member>
        <member name="T:NLog.Internal.SimpleStringReader">
            <summary>
            Simple character tokenizer.
            </summary>
        </member>
        <member name="M:NLog.Internal.SimpleStringReader.#ctor(System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Internal.SimpleStringReader" /> class.
            </summary>
            <param name="text">The text to be tokenized.</param>
        </member>
        <member name="P:NLog.Internal.SimpleStringReader.Position">
            <summary>
            Current position in <see cref="P:NLog.Internal.SimpleStringReader.Text"/>
            </summary>
        </member>
        <member name="P:NLog.Internal.SimpleStringReader.Text">
            <summary>
            Full text to be parsed
            </summary>
        </member>
        <member name="M:NLog.Internal.SimpleStringReader.Peek">
            <summary>
            Check current char while not changing the position.
            </summary>
            <returns></returns>
        </member>
        <member name="M:NLog.Internal.SimpleStringReader.Read">
            <summary>
            Read the current char and change position
            </summary>
            <returns></returns>
        </member>
        <member name="M:NLog.Internal.SimpleStringReader.Substring(System.Int32,System.Int32)">
            <summary>
            Get the substring of the <see cref="P:NLog.Internal.SimpleStringReader.Text"/>
            </summary>
            <param name="startIndex"></param>
            <param name="endIndex"></param>
            <returns></returns>
        </member>
        <member name="T:NLog.Internal.SingleCallContinuation">
            <summary>
            Implements a single-call guard around given continuation function.
            </summary>
        </member>
        <member name="M:NLog.Internal.SingleCallContinuation.#ctor(NLog.Common.AsyncContinuation)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Internal.SingleCallContinuation"/> class.
            </summary>
            <param name="asyncContinuation">The asynchronous continuation.</param>
        </member>
        <member name="M:NLog.Internal.SingleCallContinuation.Function(System.Exception)">
            <summary>
            Continuation function which implements the single-call guard.
            </summary>
            <param name="exception">The exception.</param>
        </member>
        <member name="T:NLog.Internal.SingleItemOptimizedHashSet`1">
            <summary>
            HashSet optimized for single item
            </summary>
            <typeparam name="T"></typeparam>
        </member>
        <member name="M:NLog.Internal.SingleItemOptimizedHashSet`1.SingleItemScopedInsert.#ctor(`0,NLog.Internal.SingleItemOptimizedHashSet{`0}@,System.Boolean,System.Collections.Generic.IEqualityComparer{`0})">
            <summary>
            Insert single item on scope start, and remove on scope exit
            </summary>
            <param name="singleItem">Item to insert in scope</param>
            <param name="existing">Existing hashset to update</param>
            <param name="forceHashSet">Force allocation of real hashset-container</param>
            <param name="comparer">HashSet EqualityComparer</param>
        </member>
        <member name="M:NLog.Internal.SingleItemOptimizedHashSet`1.Add(`0)">
            <summary>
            Add item to collection, if it not already exists
            </summary>
            <param name="item">Item to insert</param>
        </member>
        <member name="M:NLog.Internal.SingleItemOptimizedHashSet`1.Clear">
            <summary>
            Clear hashset
            </summary>
        </member>
        <member name="M:NLog.Internal.SingleItemOptimizedHashSet`1.Contains(`0)">
            <summary>
            Check if hashset contains item
            </summary>
            <param name="item"></param>
            <returns>Item exists in hashset (true/false)</returns>
        </member>
        <member name="M:NLog.Internal.SingleItemOptimizedHashSet`1.Remove(`0)">
            <summary>
            Remove item from hashset
            </summary>
            <param name="item"></param>
            <returns>Item removed from hashset (true/false)</returns>
        </member>
        <member name="M:NLog.Internal.SingleItemOptimizedHashSet`1.CopyTo(`0[],System.Int32)">
            <summary>
            Copy items in hashset to array
            </summary>
            <param name="array">Destination array</param>
            <param name="arrayIndex">Array offset</param>
        </member>
        <member name="M:NLog.Internal.SingleItemOptimizedHashSet`1.GetEnumerator">
            <summary>
            Create hashset enumerator
            </summary>
            <returns>Enumerator</returns>
        </member>
        <member name="T:NLog.Internal.SortHelpers">
            <summary>
            Provides helpers to sort log events and associated continuations.
            </summary>
        </member>
        <member name="T:NLog.Internal.SortHelpers.KeySelector`2">
            <summary>
            Key selector delegate.
            </summary>
            <typeparam name="TValue">The type of the value.</typeparam>
            <typeparam name="TKey">The type of the key.</typeparam>
            <param name="value">Value to extract key information from.</param>
            <returns>Key selected from log event.</returns>
        </member>
        <member name="M:NLog.Internal.SortHelpers.BucketSort``2(System.Collections.Generic.IEnumerable{``0},NLog.Internal.SortHelpers.KeySelector{``0,``1})">
            <summary>
            Performs bucket sort (group by) on an array of items and returns a dictionary for easy traversal of the result set.
            </summary>
            <typeparam name="TValue">The type of the value.</typeparam>
            <typeparam name="TKey">The type of the key.</typeparam>
            <param name="inputs">The inputs.</param>
            <param name="keySelector">The key selector function.</param>
            <returns>
            Dictionary where keys are unique input keys, and values are lists of <see cref="T:NLog.Common.AsyncLogEventInfo"/>.
            </returns>
        </member>
        <member name="M:NLog.Internal.SortHelpers.BucketSort``2(System.Collections.Generic.IList{``0},NLog.Internal.SortHelpers.KeySelector{``0,``1})">
            <summary>
            Performs bucket sort (group by) on an array of items and returns a dictionary for easy traversal of the result set.
            </summary>
            <typeparam name="TValue">The type of the value.</typeparam>
            <typeparam name="TKey">The type of the key.</typeparam>
            <param name="inputs">The inputs.</param>
            <param name="keySelector">The key selector function.</param>
            <returns>
            Dictionary where keys are unique input keys, and values are lists of <see cref="T:NLog.Common.AsyncLogEventInfo"/>.
            </returns>
        </member>
        <member name="M:NLog.Internal.SortHelpers.BucketSort``2(System.Collections.Generic.IList{``0},NLog.Internal.SortHelpers.KeySelector{``0,``1},System.Collections.Generic.IEqualityComparer{``1})">
            <summary>
            Performs bucket sort (group by) on an array of items and returns a dictionary for easy traversal of the result set.
            </summary>
            <typeparam name="TValue">The type of the value.</typeparam>
            <typeparam name="TKey">The type of the key.</typeparam>
            <param name="inputs">The inputs.</param>
            <param name="keySelector">The key selector function.</param>
            <param name="keyComparer">The key comparer function.</param>
            <returns>
            Dictionary where keys are unique input keys, and values are lists of <see cref="T:NLog.Common.AsyncLogEventInfo"/>.
            </returns>
        </member>
        <member name="T:NLog.Internal.SortHelpers.ReadOnlySingleBucketDictionary`2">
             <summary>
             Single-Bucket optimized readonly dictionary. Uses normal internally Dictionary if multiple buckets are needed.
            
             Avoids allocating a new dictionary, when all items are using the same bucket
             </summary>
             <typeparam name="TKey">The type of the key.</typeparam>
             <typeparam name="TValue">The type of the value.</typeparam>
        </member>
        <member name="P:NLog.Internal.SortHelpers.ReadOnlySingleBucketDictionary`2.Count">
            <inheritDoc/>
        </member>
        <member name="P:NLog.Internal.SortHelpers.ReadOnlySingleBucketDictionary`2.Keys">
            <inheritDoc/>
        </member>
        <member name="P:NLog.Internal.SortHelpers.ReadOnlySingleBucketDictionary`2.Values">
            <inheritDoc/>
        </member>
        <member name="P:NLog.Internal.SortHelpers.ReadOnlySingleBucketDictionary`2.IsReadOnly">
            <inheritDoc/>
        </member>
        <member name="P:NLog.Internal.SortHelpers.ReadOnlySingleBucketDictionary`2.Item(`0)">
            <summary>
            Allows direct lookup of existing keys. If trying to access non-existing key exception is thrown.
            Consider to use <see cref="M:NLog.Internal.SortHelpers.ReadOnlySingleBucketDictionary`2.TryGetValue(`0,`1@)"/> instead for better safety.
            </summary>
            <param name="key">Key value for lookup</param>
            <returns>Mapped value found</returns>
        </member>
        <member name="T:NLog.Internal.SortHelpers.ReadOnlySingleBucketDictionary`2.Enumerator">
            <summary>
            Non-Allocating struct-enumerator
            </summary>
        </member>
        <member name="M:NLog.Internal.SortHelpers.ReadOnlySingleBucketDictionary`2.System#Collections#Generic#IEnumerable{System#Collections#Generic#KeyValuePair{TKey,TValue}}#GetEnumerator">
            <inheritDoc/>
        </member>
        <member name="M:NLog.Internal.SortHelpers.ReadOnlySingleBucketDictionary`2.System#Collections#IEnumerable#GetEnumerator">
            <inheritDoc/>
        </member>
        <member name="M:NLog.Internal.SortHelpers.ReadOnlySingleBucketDictionary`2.ContainsKey(`0)">
            <inheritDoc/>
        </member>
        <member name="M:NLog.Internal.SortHelpers.ReadOnlySingleBucketDictionary`2.Add(`0,`1)">
            <summary>Will always throw, as dictionary is readonly</summary>
        </member>
        <member name="M:NLog.Internal.SortHelpers.ReadOnlySingleBucketDictionary`2.Remove(`0)">
            <summary>Will always throw, as dictionary is readonly</summary>
        </member>
        <member name="M:NLog.Internal.SortHelpers.ReadOnlySingleBucketDictionary`2.TryGetValue(`0,`1@)">
            <inheritDoc/>
        </member>
        <member name="M:NLog.Internal.SortHelpers.ReadOnlySingleBucketDictionary`2.Add(System.Collections.Generic.KeyValuePair{`0,`1})">
            <summary>Will always throw, as dictionary is readonly</summary>
        </member>
        <member name="M:NLog.Internal.SortHelpers.ReadOnlySingleBucketDictionary`2.Clear">
            <summary>Will always throw, as dictionary is readonly</summary>
        </member>
        <member name="M:NLog.Internal.SortHelpers.ReadOnlySingleBucketDictionary`2.Contains(System.Collections.Generic.KeyValuePair{`0,`1})">
            <inheritDoc/>
        </member>
        <member name="M:NLog.Internal.SortHelpers.ReadOnlySingleBucketDictionary`2.CopyTo(System.Collections.Generic.KeyValuePair{`0,`1}[],System.Int32)">
            <inheritDoc/>
        </member>
        <member name="M:NLog.Internal.SortHelpers.ReadOnlySingleBucketDictionary`2.Remove(System.Collections.Generic.KeyValuePair{`0,`1})">
            <summary>Will always throw, as dictionary is readonly</summary>
        </member>
        <member name="T:NLog.Internal.StackTraceUsageUtils">
            <summary>
            Utilities for dealing with <see cref="T:NLog.Config.StackTraceUsage"/> values.
            </summary>
        </member>
        <member name="M:NLog.Internal.StackTraceUsageUtils.GetClassFullName">
            <summary>
            Gets the fully qualified name of the class invoking the calling method, including the
            namespace but not the assembly.
            </summary>
        </member>
        <member name="M:NLog.Internal.StackTraceUsageUtils.GetClassFullName(System.Diagnostics.StackFrame)">
            <summary>
            Gets the fully qualified name of the class invoking the calling method, including the
            namespace but not the assembly.
            </summary>
            <param name="stackFrame">StackFrame from the calling method</param>
            <returns>Fully qualified class name</returns>
        </member>
        <member name="M:NLog.Internal.StackTraceUsageUtils.LookupAssemblyFromMethod(System.Reflection.MethodBase)">
            <summary>
            Returns the assembly from the provided StackFrame (If not internal assembly)
            </summary>
            <returns>Valid assembly, or null if assembly was internal</returns>
        </member>
        <member name="M:NLog.Internal.StackTraceUsageUtils.LookupClassNameFromStackFrame(System.Diagnostics.StackFrame)">
            <summary>
            Returns the classname from the provided StackFrame (If not from internal assembly)
            </summary>
            <param name="stackFrame"></param>
            <returns>Valid class name, or empty string if assembly was internal</returns>
        </member>
        <member name="T:NLog.Internal.StreamHelpers">
            <summary>
            Stream helpers
            </summary>
        </member>
        <member name="M:NLog.Internal.StreamHelpers.CopyAndSkipBom(System.IO.Stream,System.IO.Stream,System.Text.Encoding)">
            <summary>
            Copy to output stream and skip BOM if encoding is UTF8
            </summary>
            <param name="input"></param>
            <param name="output"></param>
            <param name="encoding"></param>
        </member>
        <member name="M:NLog.Internal.StreamHelpers.Copy(System.IO.Stream,System.IO.Stream)">
            <summary>
            Copy stream input to output. Skip the first bytes
            </summary>
            <param name="input">stream to read from</param>
            <param name="output">stream to write to</param>
            <remarks>.net35 doesn't have a .copyto</remarks>
        </member>
        <member name="M:NLog.Internal.StreamHelpers.CopyWithOffset(System.IO.Stream,System.IO.Stream,System.Int32)">
            <summary>
            Copy stream input to output. Skip the first bytes
            </summary>
            <param name="input">stream to read from</param>
            <param name="output">stream to write to</param>
            <param name="offset">first bytes to skip (optional)</param>
        </member>
        <member name="T:NLog.Internal.StringBuilderExt">
            <summary>
            Helpers for <see cref="T:System.Text.StringBuilder"/>, which is used in e.g. layout renderers.
            </summary>
        </member>
        <member name="M:NLog.Internal.StringBuilderExt.AppendFormattedValue(System.Text.StringBuilder,System.Object,System.String,System.IFormatProvider,NLog.IValueFormatter)">
            <summary>
            Renders the specified log event context item and appends it to the specified <see cref="T:System.Text.StringBuilder" />.
            </summary>
            <param name="builder">append to this</param>
            <param name="value">value to be appended</param>
            <param name="format">format string. If @, then serialize the value with the Default JsonConverter.</param>
            <param name="formatProvider">provider, for example culture</param>
            <param name="valueFormatter">NLog string.Format interface</param>
        </member>
        <member name="M:NLog.Internal.StringBuilderExt.AppendInvariant(System.Text.StringBuilder,System.Int32)">
            <summary>
            Appends int without using culture, and most importantly without garbage
            </summary>
            <param name="builder"></param>
            <param name="value">value to append</param>
        </member>
        <member name="M:NLog.Internal.StringBuilderExt.AppendInvariant(System.Text.StringBuilder,System.UInt32)">
             <summary>
             Appends uint without using culture, and most importantly without garbage
            
             Credits Gavin Pugh  - https://www.gavpugh.com/2010/04/01/xnac-avoiding-garbage-when-working-with-stringbuilder/
             </summary>
             <param name="builder"></param>
             <param name="value">value to append</param>
        </member>
        <member name="M:NLog.Internal.StringBuilderExt.AppendXmlDateTimeUtcRoundTripFixed(System.Text.StringBuilder,System.DateTime)">
            <summary>
            Convert DateTime into UTC and format to yyyy-MM-ddTHH:mm:ss.fffffffZ - ISO 8601 Compliant Date Format (Round-Trip-Time)
            </summary>
        </member>
        <member name="M:NLog.Internal.StringBuilderExt.ClearBuilder(System.Text.StringBuilder)">
            <summary>
            Clears the provider StringBuilder
            </summary>
            <param name="builder"></param>
        </member>
        <member name="M:NLog.Internal.StringBuilderExt.CopyToStream(System.Text.StringBuilder,System.IO.MemoryStream,System.Text.Encoding,System.Char[])">
            <summary>
            Copies the contents of the StringBuilder to the MemoryStream using the specified encoding (Without BOM/Preamble)
            </summary>
            <param name="builder">StringBuilder source</param>
            <param name="ms">MemoryStream destination</param>
            <param name="encoding">Encoding used for converter string into byte-stream</param>
            <param name="transformBuffer">Helper char-buffer to minimize memory allocations</param>
        </member>
        <member name="M:NLog.Internal.StringBuilderExt.CopyTo(System.Text.StringBuilder,System.Text.StringBuilder)">
            <summary>
            Copies the contents of the StringBuilder to the destination StringBuilder
            </summary>
            <param name="builder">StringBuilder source</param>
            <param name="destination">StringBuilder destination</param>
        </member>
        <member name="M:NLog.Internal.StringBuilderExt.IndexOf(System.Text.StringBuilder,System.Char,System.Int32)">
            <summary>
            Scans the StringBuilder for the position of needle character
            </summary>
            <param name="builder">StringBuilder source</param>
            <param name="needle">needle character to search for</param>
            <param name="startPos"></param>
            <returns>Index of the first occurrence (Else -1)</returns>
        </member>
        <member name="M:NLog.Internal.StringBuilderExt.IndexOfAny(System.Text.StringBuilder,System.Char[],System.Int32)">
            <summary>
            Scans the StringBuilder for the position of needle character
            </summary>
            <param name="builder">StringBuilder source</param>
            <param name="needles">needle characters to search for</param>
            <param name="startPos"></param>
            <returns>Index of the first occurrence (Else -1)</returns>
        </member>
        <member name="M:NLog.Internal.StringBuilderExt.EqualTo(System.Text.StringBuilder,System.Text.StringBuilder)">
            <summary>
            Compares the contents of two StringBuilders
            </summary>
            <remarks>
            Correct implementation of <see cref="M:System.Text.StringBuilder.Equals(System.Text.StringBuilder)" /> that also works when <see cref="P:System.Text.StringBuilder.Capacity"/> is not the same
            </remarks>
            <returns>True when content is the same</returns>
        </member>
        <member name="M:NLog.Internal.StringBuilderExt.EqualTo(System.Text.StringBuilder,System.String)">
            <summary>
            Compares the contents of a StringBuilder and a String
            </summary>
            <returns>True when content is the same</returns>
        </member>
        <member name="M:NLog.Internal.StringBuilderExt.Append2DigitsZeroPadded(System.Text.StringBuilder,System.Int32)">
            <summary>
            Append a number and pad with 0 to 2 digits
            </summary>
            <param name="builder">append to this</param>
            <param name="number">the number</param>
        </member>
        <member name="M:NLog.Internal.StringBuilderExt.Append4DigitsZeroPadded(System.Text.StringBuilder,System.Int32)">
            <summary>
            Append a number and pad with 0 to 4 digits
            </summary>
            <param name="builder">append to this</param>
            <param name="number">the number</param>
        </member>
        <member name="M:NLog.Internal.StringBuilderExt.AppendNumericInvariant(System.Text.StringBuilder,System.IConvertible,System.TypeCode)">
            <summary>
            Append a numeric type (byte, int, double, decimal) as string
            </summary>
        </member>
        <member name="M:NLog.Internal.StringBuilderPool.#ctor(System.Int32,System.Int32,System.Int32)">
            <summary>
            Constructor
            </summary>
            <param name="poolCapacity">Max number of items</param>
            <param name="initialBuilderCapacity">Initial StringBuilder Size</param>
            <param name="maxBuilderCapacity">Max StringBuilder Size</param>
        </member>
        <member name="M:NLog.Internal.StringBuilderPool.Acquire">
            <summary>
            Takes StringBuilder from pool
            </summary>
            <returns>Allow return to pool</returns>
        </member>
        <member name="M:NLog.Internal.StringBuilderPool.Release(System.Text.StringBuilder,System.Int32)">
            <summary>
            Releases StringBuilder back to pool at its right place
            </summary>
        </member>
        <member name="T:NLog.Internal.StringBuilderPool.ItemHolder">
            <summary>
            Keeps track of acquired pool item
            </summary>
        </member>
        <member name="M:NLog.Internal.StringBuilderPool.ItemHolder.Dispose">
            <summary>
            Releases pool item back into pool
            </summary>
        </member>
        <member name="T:NLog.Internal.StringHelpers">
            <summary>
            Helpers for <see cref="T:System.String"/>.
            </summary>
        </member>
        <member name="M:NLog.Internal.StringHelpers.IsNullOrWhiteSpace(System.String)">
            <summary>
            IsNullOrWhiteSpace, including for .NET 3.5
            </summary>
            <param name="value"></param>
            <returns></returns>
        </member>
        <member name="M:NLog.Internal.StringHelpers.Replace(System.String,System.String,System.String,System.StringComparison)">
            <summary>
            Replace string with <paramref name="comparison"/>
            </summary>
            <param name="str"></param>
            <param name="oldValue"></param>
            <param name="newValue"></param>
            <param name="comparison"></param>
            <returns>The same reference of nothing has been replaced.</returns>
        </member>
        <member name="M:NLog.Internal.StringHelpers.Join(System.String,System.Collections.Generic.IEnumerable{System.String})">
            <summary>Concatenates all the elements of a string array, using the specified separator between each element. </summary>
            <param name="separator">The string to use as a separator. <paramref name="separator" /> is included in the returned string only if <paramref name="values" /> has more than one element.</param>
            <param name="values">An collection that contains the elements to concatenate. </param>
            <returns>A string that consists of the elements in <paramref name="values" /> delimited by the <paramref name="separator" /> string. If <paramref name="values" /> is an empty array, the method returns <see cref="F:System.String.Empty" />.</returns>
            <exception cref="T:System.ArgumentNullException">
            <paramref name="values" /> is <see langword="null" />. </exception>
        </member>
        <member name="T:NLog.Internal.StringSplitter">
            <summary>
            Split a string
            </summary>
        </member>
        <member name="M:NLog.Internal.StringSplitter.SplitQuoted(System.String,System.Char,System.Char,System.Char)">
            <summary>
            Split a string, optional quoted value
            </summary>
            <param name="text">Text to split</param>
            <param name="splitChar">Character to split the <paramref name="text" /></param>
            <param name="quoteChar">Quote character</param>
            <param name="escapeChar">
            Escape for the <paramref name="quoteChar" />, not escape for the <paramref name="splitChar" />
            , use quotes for that.
            </param>
        </member>
        <member name="M:NLog.Internal.StringSplitter.SplitQuoted2(System.String,System.Char,System.Char,System.Char)">
            <summary>
            Split a string, optional quoted value
            </summary>
            <param name="text">Text to split</param>
            <param name="splitChar">Character to split the <paramref name="text" /></param>
            <param name="quoteChar">Quote character</param>
            <param name="escapeChar">
            Escape for the <paramref name="quoteChar" />, not escape for the <paramref name="splitChar" />
            , use quotes for that.
            </param>
        </member>
        <member name="T:NLog.Internal.TargetWithFilterChain">
            <summary>
            Represents target with a chain of filters which determine
            whether logging should happen.
            </summary>
        </member>
        <member name="M:NLog.Internal.TargetWithFilterChain.#ctor(NLog.Targets.Target,System.Collections.Generic.IList{NLog.Filters.Filter},NLog.Filters.FilterResult)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Internal.TargetWithFilterChain" /> class.
            </summary>
            <param name="target">The target.</param>
            <param name="filterChain">The filter chain.</param>
            <param name="filterDefaultAction">Default action if none of the filters match.</param>
        </member>
        <member name="P:NLog.Internal.TargetWithFilterChain.Target">
            <summary>
            Gets the target.
            </summary>
            <value>The target.</value>
        </member>
        <member name="P:NLog.Internal.TargetWithFilterChain.FilterChain">
            <summary>
            Gets the filter chain.
            </summary>
            <value>The filter chain.</value>
        </member>
        <member name="P:NLog.Internal.TargetWithFilterChain.NextInChain">
            <summary>
            Gets or sets the next <see cref="T:NLog.Internal.TargetWithFilterChain"/> item in the chain.
            </summary>
            <value>The next item in the chain.</value>
            <example>This is for example the 'target2' logger in writeTo='target1,target2'  </example>
        </member>
        <member name="P:NLog.Internal.TargetWithFilterChain.StackTraceUsage">
            <summary>
            Gets the stack trace usage.
            </summary>
            <returns>A <see cref="P:NLog.Internal.TargetWithFilterChain.StackTraceUsage" /> value that determines stack trace handling.</returns>
        </member>
        <member name="P:NLog.Internal.TargetWithFilterChain.FilterDefaultAction">
            <summary>
            Default action if none of the filters match.
            </summary>
        </member>
        <member name="M:NLog.Internal.TargetWithFilterChain.CallSiteKey.GetHashCode">
            <summary>
            Serves as a hash function for a particular type.
            </summary>
        </member>
        <member name="M:NLog.Internal.TargetWithFilterChain.CallSiteKey.Equals(System.Object)">
            <summary>
            Determines if two objects are equal in value.
            </summary>
            <param name="obj">Other object to compare to.</param>
            <returns>True if objects are equal, false otherwise.</returns>
        </member>
        <member name="M:NLog.Internal.TargetWithFilterChain.CallSiteKey.Equals(NLog.Internal.TargetWithFilterChain.CallSiteKey)">
            <summary>
            Determines if two objects of the same type are equal in value.
            </summary>
            <param name="other">Other object to compare to.</param>
            <returns>True if objects are equal, false otherwise.</returns>
        </member>
        <member name="T:NLog.Internal.TimeoutContinuation">
            <summary>
            Wraps <see cref="T:NLog.Common.AsyncContinuation"/> with a timeout.
            </summary>
        </member>
        <member name="M:NLog.Internal.TimeoutContinuation.#ctor(NLog.Common.AsyncContinuation,System.TimeSpan)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Internal.TimeoutContinuation"/> class.
            </summary>
            <param name="asyncContinuation">The asynchronous continuation.</param>
            <param name="timeout">The timeout.</param>
        </member>
        <member name="M:NLog.Internal.TimeoutContinuation.Function(System.Exception)">
            <summary>
            Continuation function which implements the timeout logic.
            </summary>
            <param name="exception">The exception.</param>
        </member>
        <member name="M:NLog.Internal.TimeoutContinuation.Dispose">
            <summary>
            Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
            </summary>
        </member>
        <member name="T:NLog.Internal.UrlHelper">
            <summary>
            URL Encoding helper.
            </summary>
        </member>
        <member name="F:NLog.Internal.UrlHelper.EscapeEncodingOptions.UriString">
            <summary>Allow UnreservedMarks instead of ReservedMarks, as specified by chosen RFC</summary>
        </member>
        <member name="F:NLog.Internal.UrlHelper.EscapeEncodingOptions.LegacyRfc2396">
            <summary>Use RFC2396 standard (instead of RFC3986)</summary>
        </member>
        <member name="F:NLog.Internal.UrlHelper.EscapeEncodingOptions.LowerCaseHex">
            <summary>Should use lowercase when doing HEX escaping of special characters</summary>
        </member>
        <member name="F:NLog.Internal.UrlHelper.EscapeEncodingOptions.SpaceAsPlus">
            <summary>Replace space ' ' with '+' instead of '%20'</summary>
        </member>
        <member name="F:NLog.Internal.UrlHelper.EscapeEncodingOptions.NLogLegacy">
            <summary>Skip UTF8 encoding, and prefix special characters with '%u'</summary>
        </member>
        <member name="M:NLog.Internal.UrlHelper.EscapeDataEncode(System.String,System.Text.StringBuilder,NLog.Internal.UrlHelper.EscapeEncodingOptions)">
            <summary>
            Escape unicode string data for use in http-requests
            </summary>
            <param name="source">unicode string-data to be encoded</param>
            <param name="target">target for the encoded result</param>
            <param name="options"><see cref="T:NLog.Internal.UrlHelper.EscapeEncodingOptions"/>s for how to perform the encoding</param>
        </member>
        <member name="M:NLog.Internal.UrlHelper.WriteWideChars(System.Text.StringBuilder,System.Char[],System.Byte[],System.Char[])">
            <summary>
            Convert the wide-char into utf8-bytes, and then escape
            </summary>
        </member>
        <member name="M:NLog.Internal.UrlHelper.IsAllowedChar(NLog.Internal.UrlHelper.EscapeEncodingOptions,System.Char)">
            <summary>
            Is allowed?
            </summary>
            <param name="options"></param>
            <param name="ch"></param>
            <returns></returns>
        </member>
        <member name="M:NLog.Internal.UrlHelper.IsSimpleCharOrNumber(System.Char)">
            <summary>
            Is a-z / A-Z / 0-9
            </summary>
            <param name="ch"></param>
            <returns></returns>
        </member>
        <member name="T:NLog.Internal.Xamarin.PreserveAttribute">
            <summary>
            Prevents the Xamarin linker from linking the target.
            </summary>
            <remarks>
            By applying this attribute all of the members of the target will be kept as if they had been referenced by the code.
            </remarks>
        </member>
        <member name="P:NLog.Internal.Xamarin.PreserveAttribute.AllMembers">
            <summary>
            Ensures that all members of this type are preserved
            </summary>
        </member>
        <member name="P:NLog.Internal.Xamarin.PreserveAttribute.Conditional">
            <summary>
            Flags the method as a method to preserve during linking if the container class is pulled in.
            </summary>
        </member>
        <member name="T:NLog.Internal.XmlHelper">
            <summary>
             Helper class for XML
            </summary>
        </member>
        <member name="M:NLog.Internal.XmlHelper.RemoveInvalidXmlChars(System.String)">
            <summary>
            removes any unusual unicode characters that can't be encoded into XML
            </summary>
        </member>
        <member name="M:NLog.Internal.XmlHelper.CreateValidXmlString(System.String)">
            <summary>
            Cleans string of any invalid XML chars found
            </summary>
            <param name="text">unclean string</param>
            <returns>string with only valid XML chars</returns>
        </member>
        <member name="M:NLog.Internal.XmlHelper.SmallAndNoEscapeNeeded(System.String,System.Boolean)">
            <summary>
            Pretest, small text and not escape needed
            </summary>
            <param name="text"></param>
            <param name="xmlEncodeNewlines"></param>
            <returns></returns>
        </member>
        <member name="M:NLog.Internal.XmlHelper.XmlConvertToStringSafe(System.Object)">
            <summary>
            Converts object value to invariant format, and strips any invalid xml-characters
            </summary>
            <param name="value">Object value</param>
            <returns>Object value converted to string</returns>
        </member>
        <member name="M:NLog.Internal.XmlHelper.XmlConvertToString(System.Object)">
            <summary>
            Converts object value to invariant format (understood by JavaScript)
            </summary>
            <param name="value">Object value</param>
            <returns>Object value converted to string</returns>
        </member>
        <member name="M:NLog.Internal.XmlHelper.XmlConvertToElementName(System.String)">
            <summary>
            XML elements must follow these naming rules:
             - Element names are case-sensitive
             - Element names must start with a letter or underscore
             - Element names can contain letters, digits, hyphens, underscores, and periods
             - Element names cannot contain spaces
            </summary>
            <param name="xmlElementName"></param>
        </member>
        <member name="M:NLog.Internal.XmlHelper.XmlConvertToString(System.IConvertible,System.TypeCode,System.Boolean)">
            <summary>
            Converts object value to invariant format (understood by JavaScript)
            </summary>
            <param name="value">Object value</param>
            <param name="objTypeCode">Object TypeCode</param>
            <param name="safeConversion">Check and remove unusual unicode characters from the result string.</param>
            <returns>Object value converted to string</returns>
        </member>
        <member name="M:NLog.Internal.XmlHelper.WriteAttributeSafeString(System.Xml.XmlWriter,System.String,System.String)">
            <summary>
            Safe version of WriteAttributeString
            </summary>
            <param name="writer"></param>
            <param name="localName"></param>
            <param name="value"></param>
        </member>
        <member name="M:NLog.Internal.XmlHelper.WriteElementSafeString(System.Xml.XmlWriter,System.String,System.String,System.String,System.String)">
            <summary>
            Safe version of WriteElementSafeString
            </summary>
            <param name="writer"></param>
            <param name="prefix"></param>
            <param name="localName"></param>
            <param name="ns"></param>
            <param name="value"></param>
        </member>
        <member name="M:NLog.Internal.XmlHelper.WriteSafeCData(System.Xml.XmlWriter,System.String)">
            <summary>
            Safe version of WriteCData
            </summary>
            <param name="writer"></param>
            <param name="value"></param>
        </member>
        <member name="T:NLog.IObjectTypeTransformer">
            <summary>
            Interface for handling object transformation
            </summary>
        </member>
        <member name="M:NLog.IObjectTypeTransformer.TryTransformObject(System.Object)">
            <summary>
            Takes a dangerous (or massive) object and converts into a safe (or reduced) object
            </summary>
            <returns>
            Null if unknown object, or object cannot be handled
            </returns>
        </member>
        <member name="T:NLog.ISuppress">
             <summary>
             Obsolete and replaced by <see cref="T:NLog.ILogger"/> with NLog v5.3.
            
             Provides an interface to execute System.Actions without surfacing any exceptions raised for that action.
             </summary>
        </member>
        <member name="M:NLog.ISuppress.Swallow(System.Action)">
            <summary>
            Runs the provided action. If the action throws, the exception is logged at <c>Error</c> level. The exception is not propagated outside of this method.
            </summary>
            <param name="action">Action to execute.</param>
        </member>
        <member name="M:NLog.ISuppress.Swallow``1(System.Func{``0})">
            <summary>
            Runs the provided function and returns its result. If an exception is thrown, it is logged at <c>Error</c> level.
            The exception is not propagated outside of this method; a default value is returned instead.
            </summary>
            <typeparam name="T">Return type of the provided function.</typeparam>
            <param name="func">Function to run.</param>
            <returns>Result returned by the provided function or the default value of type <typeparamref name="T"/> in case of exception.</returns>
        </member>
        <member name="M:NLog.ISuppress.Swallow``1(System.Func{``0},``0)">
            <summary>
            Runs the provided function and returns its result. If an exception is thrown, it is logged at <c>Error</c> level.
            The exception is not propagated outside of this method; a fallback value is returned instead.
            </summary>
            <typeparam name="T">Return type of the provided function.</typeparam>
            <param name="func">Function to run.</param>
            <param name="fallback">Fallback value to return in case of exception.</param>
            <returns>Result returned by the provided function or fallback value in case of exception.</returns>
        </member>
        <member name="M:NLog.ISuppress.Swallow(System.Threading.Tasks.Task)">
            <summary>
            Logs an exception is logged at <c>Error</c> level if the provided task does not run to completion.
            </summary>
            <param name="task">The task for which to log an error if it does not run to completion.</param>
            <remarks>This method is useful in fire-and-forget situations, where application logic does not depend on completion of task. This method is avoids C# warning CS4014 in such situations.</remarks>
        </member>
        <member name="M:NLog.ISuppress.SwallowAsync(System.Threading.Tasks.Task)">
            <summary>
            Returns a task that completes when a specified task to completes. If the task does not run to completion, an exception is logged at <c>Error</c> level. The returned task always runs to completion.
            </summary>
            <param name="task">The task for which to log an error if it does not run to completion.</param>
            <returns>A task that completes in the <see cref="F:System.Threading.Tasks.TaskStatus.RanToCompletion"/> state when <paramref name="task"/> completes.</returns>
        </member>
        <member name="M:NLog.ISuppress.SwallowAsync(System.Func{System.Threading.Tasks.Task})">
            <summary>
            Runs async action. If the action throws, the exception is logged at <c>Error</c> level. The exception is not propagated outside of this method.
            </summary>
            <param name="asyncAction">Async action to execute.</param>
            <returns>A task that completes in the <see cref="F:System.Threading.Tasks.TaskStatus.RanToCompletion"/> state when <paramref name="asyncAction"/> completes.</returns>
        </member>
        <member name="M:NLog.ISuppress.SwallowAsync``1(System.Func{System.Threading.Tasks.Task{``0}})">
            <summary>
            Runs the provided async function and returns its result. If the task does not run to completion, an exception is logged at <c>Error</c> level.
            The exception is not propagated outside of this method; a default value is returned instead.
            </summary>
            <typeparam name="TResult">Return type of the provided function.</typeparam>
            <param name="asyncFunc">Async function to run.</param>
            <returns>A task that represents the completion of the supplied task. If the supplied task ends in the <see cref="F:System.Threading.Tasks.TaskStatus.RanToCompletion"/> state, the result of the new task will be the result of the supplied task; otherwise, the result of the new task will be the default value of type <typeparamref name="TResult"/>.</returns>
        </member>
        <member name="M:NLog.ISuppress.SwallowAsync``1(System.Func{System.Threading.Tasks.Task{``0}},``0)">
            <summary>
            Runs the provided async function and returns its result. If the task does not run to completion, an exception is logged at <c>Error</c> level.
            The exception is not propagated outside of this method; a fallback value is returned instead.
            </summary>
            <typeparam name="TResult">Return type of the provided function.</typeparam>
            <param name="asyncFunc">Async function to run.</param>
            <param name="fallback">Fallback value to return if the task does not end in the <see cref="F:System.Threading.Tasks.TaskStatus.RanToCompletion"/> state.</param>
            <returns>A task that represents the completion of the supplied task. If the supplied task ends in the <see cref="F:System.Threading.Tasks.TaskStatus.RanToCompletion"/> state, the result of the new task will be the result of the supplied task; otherwise, the result of the new task will be the fallback value.</returns>
        </member>
        <member name="T:NLog.IValueFormatter">
            <summary>
            Render a message template property to a string
            </summary>
        </member>
        <member name="M:NLog.IValueFormatter.FormatValue(System.Object,System.String,NLog.MessageTemplates.CaptureType,System.IFormatProvider,System.Text.StringBuilder)">
            <summary>
            Serialization of an object, e.g. JSON and append to <paramref name="builder"/>
            </summary>
            <param name="value">The object to serialize to string.</param>
            <param name="format">Parameter Format</param>
            <param name="captureType">Parameter CaptureType</param>
            <param name="formatProvider">An object that supplies culture-specific formatting information.</param>
            <param name="builder">Output destination.</param>
            <returns>Serialize succeeded (true/false)</returns>
        </member>
        <member name="T:NLog.LayoutRenderers.AllEventPropertiesLayoutRenderer">
            <summary>
            Log event context data.
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/All-Event-Properties-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/All-Event-Properties-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="M:NLog.LayoutRenderers.AllEventPropertiesLayoutRenderer.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.AllEventPropertiesLayoutRenderer"/> class.
            </summary>
        </member>
        <member name="P:NLog.LayoutRenderers.AllEventPropertiesLayoutRenderer.Separator">
            <summary>
            Gets or sets string that will be used to separate key/value pairs.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.AllEventPropertiesLayoutRenderer.IncludeEmptyValues">
             <summary>
             Get or set if empty values should be included.
            
             A value is empty when null or in case of a string, null or empty string.
             </summary>
             <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.AllEventPropertiesLayoutRenderer.IncludeScopeProperties">
            <summary>
            Gets or sets whether to include the contents of the <see cref="T:NLog.ScopeContext"/> properties-dictionary.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.AllEventPropertiesLayoutRenderer.Exclude">
            <summary>
            Gets or sets the keys to exclude from the output. If omitted, none are excluded.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.AllEventPropertiesLayoutRenderer.FixScopeContext">
            <summary>
            Enables capture of ScopeContext-properties from active thread context
            </summary>
        </member>
        <member name="P:NLog.LayoutRenderers.AllEventPropertiesLayoutRenderer.Format">
            <summary>
            Gets or sets how key/value pairs will be formatted.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.AllEventPropertiesLayoutRenderer.Culture">
            <summary>
            Gets or sets the culture used for rendering.
            </summary>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="M:NLog.LayoutRenderers.AllEventPropertiesLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.AmbientPropertyAttribute">
            <summary>
            Designates a property of the class as an ambient property.
            </summary>
            <example>
            non-ambient:  ${uppercase:${level}}
            ambient    :  ${level:uppercase}
            </example>
        </member>
        <member name="M:NLog.LayoutRenderers.AmbientPropertyAttribute.#ctor(System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.AmbientPropertyAttribute" /> class.
            </summary>
            <param name="name">Ambient property name.</param>
        </member>
        <member name="T:NLog.LayoutRenderers.AppDomainLayoutRenderer">
            <summary>
             Used to render the application domain name.
             </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/AppDomain-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/AppDomain-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="M:NLog.LayoutRenderers.AppDomainLayoutRenderer.#ctor">
            <summary>
            Create a new renderer
            </summary>
        </member>
        <member name="M:NLog.LayoutRenderers.AppDomainLayoutRenderer.#ctor(NLog.Internal.Fakeables.IAppEnvironment)">
            <summary>
            Create a new renderer
            </summary>
        </member>
        <member name="P:NLog.LayoutRenderers.AppDomainLayoutRenderer.Format">
            <summary>
            Format string. Possible values: "Short", "Long" or custom like {0} {1}. Default "Long"
            The first parameter is the AppDomain.Id, the second the second the AppDomain.FriendlyName
            This string is used in <see cref="M:System.String.Format(System.String,System.Object[])"/>
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="M:NLog.LayoutRenderers.AppDomainLayoutRenderer.InitializeLayoutRenderer">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.AppDomainLayoutRenderer.CloseLayoutRenderer">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.AppDomainLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.AppSettingLayoutRenderer">
            <summary>
            Render value for Application setting retrieved from App.config or Web.config file.
            </summary>
            <remarks>
            <code lang="NLog Layout Renderer">
            ${appsetting:item=mysetting:default=mydefault} - produces "mydefault" if no appsetting
            </code>
            <a href="https://github.com/NLog/NLog/wiki/AppSetting-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/AppSetting-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.AppSettingLayoutRenderer.Item">
            <summary>
             The AppSetting item-name
            </summary>
             <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.AppSettingLayoutRenderer.Name">
            <summary>
             Obsolete and replaced by <see cref="P:NLog.LayoutRenderers.AppSettingLayoutRenderer.Item"/> with NLog v4.6.
            
             The AppSetting item-name
            </summary>
        </member>
        <member name="P:NLog.LayoutRenderers.AppSettingLayoutRenderer.Default">
            <summary>
             The default value to render if the AppSetting value is null.
            </summary>
             <docgen category='Layout Options' order='10' />
        </member>
        <member name="M:NLog.LayoutRenderers.AppSettingLayoutRenderer.InitializeLayoutRenderer">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.AppSettingLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.AssemblyVersionLayoutRenderer">
            <summary>
            Renders the assembly version information for the entry assembly or a named assembly.
            </summary>
            <remarks>
            As this layout renderer uses reflection and version information is unlikely to change during application execution,
            it is recommended to use it in conjunction with the <see cref="T:NLog.LayoutRenderers.Wrappers.CachedLayoutRendererWrapper"/>.
            </remarks>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/AssemblyVersion-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/AssemblyVersion-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.AssemblyVersionLayoutRenderer.Name">
            <summary>
            The (full) name of the assembly. If <c>null</c>, using the entry assembly.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.AssemblyVersionLayoutRenderer.Type">
            <summary>
            Gets or sets the type of assembly version to retrieve.
            </summary>
            <remarks>
            Some version type and platform combinations are not fully supported.
            - UWP earlier than .NET Standard 1.5: Value for <see cref="F:NLog.LayoutRenderers.AssemblyVersionType.Assembly"/> is always returned unless the <see cref="P:NLog.LayoutRenderers.AssemblyVersionLayoutRenderer.Name"/> parameter is specified.
            </remarks>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.AssemblyVersionLayoutRenderer.Default">
            <summary>
             The default value to render if the Version is not available
            </summary>
             <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.AssemblyVersionLayoutRenderer.Format">
            <summary>
            Gets or sets the custom format of the assembly version output.
            </summary>
            <remarks>
            Supported placeholders are 'major', 'minor', 'build' and 'revision'.
            The default .NET template for version numbers is 'major.minor.build.revision'. See
            https://docs.microsoft.com/en-gb/dotnet/api/system.version?view=netframework-4.7.2#remarks
            for details.
            </remarks>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="M:NLog.LayoutRenderers.AssemblyVersionLayoutRenderer.InitializeLayoutRenderer">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.AssemblyVersionLayoutRenderer.CloseLayoutRenderer">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.AssemblyVersionLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.AssemblyVersionLayoutRenderer.GetAssembly">
            <summary>
            Gets the assembly specified by <see cref="P:NLog.LayoutRenderers.AssemblyVersionLayoutRenderer.Name"/>, or entry assembly otherwise
            </summary>
        </member>
        <member name="T:NLog.LayoutRenderers.AssemblyVersionType">
            <summary>
            Type of assembly version to retrieve.
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.AssemblyVersionType.Assembly">
            <summary>
            Gets the assembly version.
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.AssemblyVersionType.File">
            <summary>
            Gets the file version.
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.AssemblyVersionType.Informational">
            <summary>
            Gets the product version, extracted from the additional version information.
            </summary>
        </member>
        <member name="T:NLog.LayoutRenderers.BaseDirLayoutRenderer">
            <summary>
            The current application domain's base directory.
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/Basedir-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/Basedir-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.BaseDirLayoutRenderer.ProcessDir">
            <summary>
            Use base dir of current process. Alternative one can just use ${processdir}
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.BaseDirLayoutRenderer.FixTempDir">
            <summary>
            Fallback to the base dir of current process, when AppDomain.BaseDirectory is Temp-Path (.NET Core 3 - Single File Publish)
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="M:NLog.LayoutRenderers.BaseDirLayoutRenderer.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.BaseDirLayoutRenderer" /> class.
            </summary>
        </member>
        <member name="M:NLog.LayoutRenderers.BaseDirLayoutRenderer.#ctor(NLog.Internal.Fakeables.IAppEnvironment)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.BaseDirLayoutRenderer" /> class.
            </summary>
        </member>
        <member name="P:NLog.LayoutRenderers.BaseDirLayoutRenderer.File">
            <summary>
            Gets or sets the name of the file to be Path.Combine()'d with the base directory.
            </summary>
            <docgen category='Advanced Options' order='50' />
        </member>
        <member name="P:NLog.LayoutRenderers.BaseDirLayoutRenderer.Dir">
            <summary>
            Gets or sets the name of the directory to be Path.Combine()'d with the base directory.
            </summary>
            <docgen category='Advanced Options' order='50' />
        </member>
        <member name="M:NLog.LayoutRenderers.BaseDirLayoutRenderer.InitializeLayoutRenderer">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.BaseDirLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.CallSiteFileNameLayoutRenderer">
            <summary>
            The call site source file name. Full callsite <see cref="T:NLog.LayoutRenderers.CallSiteLayoutRenderer"/>
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/Callsite-file-name-layout-renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/Callsite-file-name-layout-renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.CallSiteFileNameLayoutRenderer.IncludeSourcePath">
            <summary>
            Gets or sets a value indicating whether to include source file path.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.CallSiteFileNameLayoutRenderer.SkipFrames">
            <summary>
            Gets or sets the number of frames to skip.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.CallSiteFileNameLayoutRenderer.CaptureStackTrace">
            <summary>
            Logger should capture StackTrace, if it was not provided manually
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.CallSiteFileNameLayoutRenderer.NLog#Config#IUsesStackTrace#StackTraceUsage">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.CallSiteFileNameLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.CallSiteLayoutRenderer">
            <summary>
            The call site (class name, method name and source information).
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/Callsite-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/Callsite-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.CallSiteLayoutRenderer.ClassName">
            <summary>
            Gets or sets a value indicating whether to render the class name.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.CallSiteLayoutRenderer.IncludeNamespace">
            <summary>
            Gets or sets a value indicating whether to render the include the namespace with <see cref="P:NLog.LayoutRenderers.CallSiteLayoutRenderer.ClassName"/>.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.CallSiteLayoutRenderer.MethodName">
            <summary>
            Gets or sets a value indicating whether to render the method name.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.CallSiteLayoutRenderer.CleanNamesOfAnonymousDelegates">
            <summary>
            Gets or sets a value indicating whether the method name will be cleaned up if it is detected as an anonymous delegate.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.CallSiteLayoutRenderer.CleanNamesOfAsyncContinuations">
            <summary>
            Gets or sets a value indicating whether the method and class names will be cleaned up if it is detected as an async continuation
            (everything after an await-statement inside of an async method).
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.CallSiteLayoutRenderer.SkipFrames">
            <summary>
            Gets or sets the number of frames to skip.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.CallSiteLayoutRenderer.FileName">
            <summary>
            Gets or sets a value indicating whether to render the source file name and line number.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.CallSiteLayoutRenderer.IncludeSourcePath">
            <summary>
            Gets or sets a value indicating whether to include source file path.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.CallSiteLayoutRenderer.CaptureStackTrace">
            <summary>
            Logger should capture StackTrace, if it was not provided manually
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.CallSiteLayoutRenderer.NLog#Config#IUsesStackTrace#StackTraceUsage">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.CallSiteLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.CallSiteLineNumberLayoutRenderer">
            <summary>
            The call site source line number. Full callsite <see cref="T:NLog.LayoutRenderers.CallSiteLayoutRenderer"/>
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/Callsite-line-number-layout-renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/Callsite-line-number-layout-renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.CallSiteLineNumberLayoutRenderer.SkipFrames">
            <summary>
            Gets or sets the number of frames to skip.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.CallSiteLineNumberLayoutRenderer.CaptureStackTrace">
            <summary>
            Logger should capture StackTrace, if it was not provided manually
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.CallSiteLineNumberLayoutRenderer.NLog#Config#IUsesStackTrace#StackTraceUsage">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.CallSiteLineNumberLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.CounterLayoutRenderer">
            <summary>
            A counter value (increases on each layout rendering).
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/Counter-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/Counter-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.CounterLayoutRenderer.Value">
            <summary>
            Gets or sets the initial value of the counter.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.CounterLayoutRenderer.Increment">
            <summary>
            Gets or sets the value to be added to the counter after each layout rendering.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.CounterLayoutRenderer.Sequence">
            <summary>
            Gets or sets the name of the sequence. Different named sequences can have individual values.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="M:NLog.LayoutRenderers.CounterLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.CurrentDirLayoutRenderer">
            <summary>
            The current working directory of the application.
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/CurrentDir-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/CurrentDir-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.CurrentDirLayoutRenderer.File">
            <summary>
            Gets or sets the name of the file to be Path.Combine()'d with the current directory.
            </summary>
            <docgen category='Advanced Options' order='50' />
        </member>
        <member name="P:NLog.LayoutRenderers.CurrentDirLayoutRenderer.Dir">
            <summary>
            Gets or sets the name of the directory to be Path.Combine()'d with the current directory.
            </summary>
            <docgen category='Advanced Options' order='50' />
        </member>
        <member name="M:NLog.LayoutRenderers.CurrentDirLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.DateLayoutRenderer">
            <summary>
            Current date and time.
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/Date-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/Date-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="M:NLog.LayoutRenderers.DateLayoutRenderer.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.DateLayoutRenderer" /> class.
            </summary>
        </member>
        <member name="P:NLog.LayoutRenderers.DateLayoutRenderer.Culture">
            <summary>
            Gets or sets the culture used for rendering.
            </summary>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="P:NLog.LayoutRenderers.DateLayoutRenderer.Format">
            <summary>
            Gets or sets the date format. Can be any argument accepted by DateTime.ToString(format).
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.DateLayoutRenderer.UniversalTime">
            <summary>
            Gets or sets a value indicating whether to output UTC time instead of local time.
            </summary>
            <docgen category='Layout Options' order='50' />
        </member>
        <member name="M:NLog.LayoutRenderers.DateLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.DbNullLayoutRenderer">
            <summary>
            DB null for a database
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/db-null-layout-renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/db-null-layout-renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="M:NLog.LayoutRenderers.DbNullLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.DirectorySeparatorLayoutRenderer">
            <summary>
            The OS dependent directory separator
            </summary>
        </member>
        <member name="M:NLog.LayoutRenderers.DirectorySeparatorLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.EnvironmentLayoutRenderer">
            <summary>
            The environment variable.
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/Environment-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/Environment-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.EnvironmentLayoutRenderer.Variable">
            <summary>
            Gets or sets the name of the environment variable.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.EnvironmentLayoutRenderer.Default">
            <summary>
            Gets or sets the default value to be used when the environment variable is not set.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="M:NLog.LayoutRenderers.EnvironmentLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.EnvironmentUserLayoutRenderer">
            <summary>
            Thread identity information (username).
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/Environment-User-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/Environment-User-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.EnvironmentUserLayoutRenderer.UserName">
            <summary>
            Gets or sets a value indicating whether username should be included.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.EnvironmentUserLayoutRenderer.Domain">
            <summary>
            Gets or sets a value indicating whether domain name should be included.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.EnvironmentUserLayoutRenderer.DefaultUser">
            <summary>
            Gets or sets the default value to be used when the User is not set.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.EnvironmentUserLayoutRenderer.DefaultDomain">
            <summary>
            Gets or sets the default value to be used when the Domain is not set.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="M:NLog.LayoutRenderers.EnvironmentUserLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.EventPropertiesLayoutRenderer">
            <summary>
            Log event context data. See <see cref="P:NLog.LogEventInfo.Properties"/>.
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/EventProperties-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/EventProperties-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.EventPropertiesLayoutRenderer.Item">
            <summary>
            Gets or sets the name of the item.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.EventPropertiesLayoutRenderer.Format">
            <summary>
            Format string for conversion from object to string.
            </summary>
            <docgen category='Layout Options' order='50' />
        </member>
        <member name="P:NLog.LayoutRenderers.EventPropertiesLayoutRenderer.Culture">
            <summary>
            Gets or sets the culture used for rendering.
            </summary>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="P:NLog.LayoutRenderers.EventPropertiesLayoutRenderer.ObjectPath">
            <summary>
            Gets or sets the object-property-navigation-path for lookup of nested property
            </summary>
            <docgen category='Layout Options' order='20' />
        </member>
        <member name="P:NLog.LayoutRenderers.EventPropertiesLayoutRenderer.IgnoreCase">
            <summary>
            Gets or sets whether to perform case-sensitive property-name lookup
            </summary>
        </member>
        <member name="M:NLog.LayoutRenderers.EventPropertiesLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.ExceptionDataLayoutRenderer">
            <summary>
            Render information of <see cref="P:System.Exception.Data" />
            for the exception passed to the logger call
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/ExceptionData-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/ExceptionData-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.ExceptionDataLayoutRenderer.Item">
            <summary>
            Gets or sets the key to search the exception Data for
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.ExceptionDataLayoutRenderer.BaseException">
            <summary>
            Gets or sets whether to render innermost Exception from <see cref="M:System.Exception.GetBaseException"/>
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.ExceptionDataLayoutRenderer.Format">
            <summary>
            Format string for conversion from object to string.
            </summary>
            <docgen category='Layout Options' order='50' />
        </member>
        <member name="P:NLog.LayoutRenderers.ExceptionDataLayoutRenderer.Culture">
            <summary>
            Gets or sets the culture used for rendering.
            </summary>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="M:NLog.LayoutRenderers.ExceptionDataLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.ExceptionLayoutRenderer">
            <summary>
            Exception information provided through
            a call to one of the Logger.*Exception() methods.
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/Exception-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/Exception-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="M:NLog.LayoutRenderers.ExceptionLayoutRenderer.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.ExceptionLayoutRenderer" /> class.
            </summary>
        </member>
        <member name="P:NLog.LayoutRenderers.ExceptionLayoutRenderer.Format">
            <summary>
            Gets or sets the format of the output. Must be a comma-separated list of exception
            properties: Message, Type, ShortType, ToString, Method, StackTrace.
            This parameter value is case-insensitive.
            </summary>
            <see cref="P:NLog.LayoutRenderers.ExceptionLayoutRenderer.Formats"/>
            <see cref="T:NLog.Config.ExceptionRenderingFormat"/>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.ExceptionLayoutRenderer.InnerFormat">
            <summary>
            Gets or sets the format of the output of inner exceptions. Must be a comma-separated list of exception
            properties: Message, Type, ShortType, ToString, Method, StackTrace.
            This parameter value is case-insensitive.
            </summary>
            <docgen category='Layout Options' order='50' />
        </member>
        <member name="P:NLog.LayoutRenderers.ExceptionLayoutRenderer.Separator">
            <summary>
            Gets or sets the separator used to concatenate parts specified in the Format.
            </summary>
            <docgen category='Layout Options' order='50' />
        </member>
        <member name="P:NLog.LayoutRenderers.ExceptionLayoutRenderer.ExceptionDataSeparator">
            <summary>
            Gets or sets the separator used to concatenate exception data specified in the Format.
            </summary>
            <docgen category='Layout Options' order='50' />
        </member>
        <member name="P:NLog.LayoutRenderers.ExceptionLayoutRenderer.MaxInnerExceptionLevel">
            <summary>
            Gets or sets the maximum number of inner exceptions to include in the output.
            By default inner exceptions are not enabled for compatibility with NLog 1.0.
            </summary>
            <docgen category='Layout Options' order='50' />
        </member>
        <member name="P:NLog.LayoutRenderers.ExceptionLayoutRenderer.InnerExceptionSeparator">
            <summary>
            Gets or sets the separator between inner exceptions.
            </summary>
            <docgen category='Layout Options' order='50' />
        </member>
        <member name="P:NLog.LayoutRenderers.ExceptionLayoutRenderer.BaseException">
            <summary>
            Gets or sets whether to render innermost Exception from <see cref="M:System.Exception.GetBaseException"/>
            </summary>
            <docgen category='Layout Options' order='50' />
        </member>
        <member name="P:NLog.LayoutRenderers.ExceptionLayoutRenderer.FlattenException">
            <summary>
            Gets or sets whether to collapse exception tree using <see cref="M:System.AggregateException.Flatten"/>
            </summary>
            <docgen category='Layout Options' order='50' />
        </member>
        <member name="P:NLog.LayoutRenderers.ExceptionLayoutRenderer.Formats">
            <summary>
            Gets the formats of the output of inner exceptions to be rendered in target. <see cref="T:NLog.Config.ExceptionRenderingFormat"/>
            </summary>
            <docgen category='Layout Options' order='50' />
        </member>
        <member name="P:NLog.LayoutRenderers.ExceptionLayoutRenderer.InnerFormats">
            <summary>
             Gets the formats of the output to be rendered in target. <see cref="T:NLog.Config.ExceptionRenderingFormat"/>
            </summary>
            <docgen category='Layout Options' order='50' />
        </member>
        <member name="M:NLog.LayoutRenderers.ExceptionLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.ExceptionLayoutRenderer.AppendMessage(System.Text.StringBuilder,System.Exception)">
            <summary>
            Appends the Message of an Exception to the specified <see cref="T:System.Text.StringBuilder" />.
            </summary>
            <param name="sb">The <see cref="T:System.Text.StringBuilder"/> to append the rendered data to.</param>
            <param name="ex">The exception containing the Message to append.</param>
        </member>
        <member name="M:NLog.LayoutRenderers.ExceptionLayoutRenderer.AppendMethod(System.Text.StringBuilder,System.Exception)">
            <summary>
            Appends the method name from Exception's stack trace to the specified <see cref="T:System.Text.StringBuilder" />.
            </summary>
            <param name="sb">The <see cref="T:System.Text.StringBuilder"/> to append the rendered data to.</param>
            <param name="ex">The Exception whose method name should be appended.</param>
        </member>
        <member name="M:NLog.LayoutRenderers.ExceptionLayoutRenderer.AppendStackTrace(System.Text.StringBuilder,System.Exception)">
            <summary>
            Appends the stack trace from an Exception to the specified <see cref="T:System.Text.StringBuilder" />.
            </summary>
            <param name="sb">The <see cref="T:System.Text.StringBuilder"/> to append the rendered data to.</param>
            <param name="ex">The Exception whose stack trace should be appended.</param>
        </member>
        <member name="M:NLog.LayoutRenderers.ExceptionLayoutRenderer.AppendToString(System.Text.StringBuilder,System.Exception)">
            <summary>
            Appends the result of calling ToString() on an Exception to the specified <see cref="T:System.Text.StringBuilder" />.
            </summary>
            <param name="sb">The <see cref="T:System.Text.StringBuilder"/> to append the rendered data to.</param>
            <param name="ex">The Exception whose call to ToString() should be appended.</param>
        </member>
        <member name="M:NLog.LayoutRenderers.ExceptionLayoutRenderer.AppendType(System.Text.StringBuilder,System.Exception)">
            <summary>
            Appends the type of an Exception to the specified <see cref="T:System.Text.StringBuilder" />.
            </summary>
            <param name="sb">The <see cref="T:System.Text.StringBuilder"/> to append the rendered data to.</param>
            <param name="ex">The Exception whose type should be appended.</param>
        </member>
        <member name="M:NLog.LayoutRenderers.ExceptionLayoutRenderer.AppendShortType(System.Text.StringBuilder,System.Exception)">
            <summary>
            Appends the short type of an Exception to the specified <see cref="T:System.Text.StringBuilder" />.
            </summary>
            <param name="sb">The <see cref="T:System.Text.StringBuilder"/> to append the rendered data to.</param>
            <param name="ex">The Exception whose short type should be appended.</param>
        </member>
        <member name="M:NLog.LayoutRenderers.ExceptionLayoutRenderer.AppendSource(System.Text.StringBuilder,System.Exception)">
            <summary>
            Appends the application source of an Exception to the specified <see cref="T:System.Text.StringBuilder" />.
            </summary>
            <param name="sb">The <see cref="T:System.Text.StringBuilder"/> to append the rendered data to.</param>
            <param name="ex">The Exception whose source should be appended.</param>
        </member>
        <member name="M:NLog.LayoutRenderers.ExceptionLayoutRenderer.AppendHResult(System.Text.StringBuilder,System.Exception)">
            <summary>
            Appends the HResult of an Exception to the specified <see cref="T:System.Text.StringBuilder" />.
            </summary>
            <param name="sb">The <see cref="T:System.Text.StringBuilder"/> to append the rendered data to.</param>
            <param name="ex">The Exception whose HResult should be appended.</param>
        </member>
        <member name="M:NLog.LayoutRenderers.ExceptionLayoutRenderer.AppendData(System.Text.StringBuilder,System.Exception)">
            <summary>
            Appends the contents of an Exception's Data property to the specified <see cref="T:System.Text.StringBuilder" />.
            </summary>
            <param name="sb">The <see cref="T:System.Text.StringBuilder"/> to append the rendered data to.</param>
            <param name="ex">The Exception whose Data property elements should be appended.</param>
        </member>
        <member name="M:NLog.LayoutRenderers.ExceptionLayoutRenderer.AppendSerializeObject(System.Text.StringBuilder,System.Exception)">
            <summary>
            Appends all the serialized properties of an Exception into the specified <see cref="T:System.Text.StringBuilder" />.
            </summary>
            <param name="sb">The <see cref="T:System.Text.StringBuilder"/> to append the rendered data to.</param>
            <param name="ex">The Exception whose properties should be appended.</param>
        </member>
        <member name="M:NLog.LayoutRenderers.ExceptionLayoutRenderer.AppendProperties(System.Text.StringBuilder,System.Exception)">
            <summary>
            Appends all the additional properties of an Exception like Data key-value-pairs
            </summary>
            <param name="sb">The <see cref="T:System.Text.StringBuilder"/> to append the rendered data to.</param>
            <param name="ex">The Exception whose properties should be appended.</param>
        </member>
        <member name="M:NLog.LayoutRenderers.ExceptionLayoutRenderer.CompileFormat(System.String,System.String)">
            <summary>
            Split the string and then compile into list of Rendering formats.
            </summary>
        </member>
        <member name="T:NLog.LayoutRenderers.FileContentsLayoutRenderer">
            <summary>
            Renders contents of the specified file.
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/FileContents-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/FileContents-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="M:NLog.LayoutRenderers.FileContentsLayoutRenderer.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.FileContentsLayoutRenderer" /> class.
            </summary>
        </member>
        <member name="P:NLog.LayoutRenderers.FileContentsLayoutRenderer.FileName">
            <summary>
            Gets or sets the name of the file.
            </summary>
            <docgen category='File Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.FileContentsLayoutRenderer.Encoding">
            <summary>
            Gets or sets the encoding used in the file.
            </summary>
            <value>The encoding.</value>
            <docgen category='File Options' order='10' />
        </member>
        <member name="M:NLog.LayoutRenderers.FileContentsLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.FuncLayoutRenderer">
            <summary>
            A layout renderer which could have different behavior per instance by using a <see cref="T:System.Func`1"/>.
            </summary>
        </member>
        <member name="M:NLog.LayoutRenderers.FuncLayoutRenderer.#ctor(System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.FuncLayoutRenderer"/> class.
            </summary>
            <param name="layoutRendererName">Name without ${}.</param>
        </member>
        <member name="M:NLog.LayoutRenderers.FuncLayoutRenderer.#ctor(System.String,System.Func{NLog.LogEventInfo,NLog.Config.LoggingConfiguration,System.Object})">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.FuncLayoutRenderer"/> class.
            </summary>
            <param name="layoutRendererName">Name without ${}.</param>
            <param name="renderMethod">Method that renders the layout.</param>
        </member>
        <member name="P:NLog.LayoutRenderers.FuncLayoutRenderer.LayoutRendererName">
            <summary>
            Name used in config without ${}. E.g. "test" could be used as "${test}".
            </summary>
        </member>
        <member name="P:NLog.LayoutRenderers.FuncLayoutRenderer.RenderMethod">
             <summary>
             Method that renders the layout.
            
             This public property will be removed in NLog 5.
             </summary>
        </member>
        <member name="P:NLog.LayoutRenderers.FuncLayoutRenderer.Format">
            <summary>
            Format string for conversion from object to string.
            </summary>
            <docgen category='Layout Options' order='50' />
        </member>
        <member name="P:NLog.LayoutRenderers.FuncLayoutRenderer.Culture">
            <summary>
            Gets or sets the culture used for rendering.
            </summary>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="M:NLog.LayoutRenderers.FuncLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.FuncLayoutRenderer.RenderValue(NLog.LogEventInfo)">
            <summary>
            Render the value for this log event
            </summary>
            <param name="logEvent">The logging event.</param>
            <returns>The value.</returns>
        </member>
        <member name="T:NLog.LayoutRenderers.FuncThreadAgnosticLayoutRenderer">
            <summary>
            A layout renderer which could have different behavior per instance by using a <see cref="T:System.Func`1"/>.
            </summary>
        </member>
        <member name="M:NLog.LayoutRenderers.FuncThreadAgnosticLayoutRenderer.#ctor(System.String,System.Func{NLog.LogEventInfo,NLog.Config.LoggingConfiguration,System.Object})">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.FuncThreadAgnosticLayoutRenderer"/> class.
            </summary>
            <param name="layoutRendererName">Name without ${}.</param>
            <param name="renderMethod">Method that renders the layout.</param>
        </member>
        <member name="T:NLog.LayoutRenderers.GarbageCollectorInfoLayoutRenderer">
            <summary>
            The information about the garbage collector.
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/Gc-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/Gc-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.GarbageCollectorInfoLayoutRenderer.Property">
            <summary>
            Gets or sets the property to retrieve.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="M:NLog.LayoutRenderers.GarbageCollectorInfoLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.GarbageCollectorProperty">
            <summary>
            Gets or sets the property of System.GC to retrieve.
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.GarbageCollectorProperty.TotalMemory">
            <summary>
            Total memory allocated.
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.GarbageCollectorProperty.TotalMemoryForceCollection">
            <summary>
            Total memory allocated (perform full garbage collection first).
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.GarbageCollectorProperty.CollectionCount0">
            <summary>
            Gets the number of Gen0 collections.
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.GarbageCollectorProperty.CollectionCount1">
            <summary>
            Gets the number of Gen1 collections.
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.GarbageCollectorProperty.CollectionCount2">
            <summary>
            Gets the number of Gen2 collections.
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.GarbageCollectorProperty.MaxGeneration">
            <summary>
            Maximum generation number supported by GC.
            </summary>
        </member>
        <member name="T:NLog.LayoutRenderers.GdcLayoutRenderer">
            <summary>
            Render a Global Diagnostics Context item. See <see cref="T:NLog.GlobalDiagnosticsContext"/>
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/Gdc-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/Gdc-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.GdcLayoutRenderer.Item">
            <summary>
            Gets or sets the name of the item.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.GdcLayoutRenderer.Format">
            <summary>
            Format string for conversion from object to string.
            </summary>
            <docgen category='Layout Options' order='50' />
        </member>
        <member name="P:NLog.LayoutRenderers.GdcLayoutRenderer.Culture">
            <summary>
            Gets or sets the culture used for rendering.
            </summary>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="M:NLog.LayoutRenderers.GdcLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.GuidLayoutRenderer">
            <summary>
            Globally-unique identifier (GUID).
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/Guid-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/Guid-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.GuidLayoutRenderer.Format">
            <summary>
            Gets or sets the GUID format as accepted by Guid.ToString() method.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.GuidLayoutRenderer.GeneratedFromLogEvent">
            <summary>
            Generate the Guid from the NLog LogEvent (Will be the same for all targets)
            </summary>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="M:NLog.LayoutRenderers.GuidLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.HostNameLayoutRenderer">
            <summary>
            The host name that the process is running on.
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/HostName-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/HostName-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="M:NLog.LayoutRenderers.HostNameLayoutRenderer.InitializeLayoutRenderer">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.HostNameLayoutRenderer.GetHostName">
            <summary>
            Gets the host name and falls back to computer name if not available
            </summary>
        </member>
        <member name="M:NLog.LayoutRenderers.HostNameLayoutRenderer.TryLookupValue(System.Func{System.String},System.String)">
            <summary>
            Tries the lookup value.
            </summary>
            <param name="lookupFunc">The lookup function.</param>
            <param name="lookupType">Type of the lookup.</param>
            <returns></returns>
        </member>
        <member name="M:NLog.LayoutRenderers.HostNameLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.IdentityLayoutRenderer">
            <summary>
            Thread identity information (name and authentication information).
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/Identity-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/Identity-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.IdentityLayoutRenderer.Separator">
            <summary>
            Gets or sets the separator to be used when concatenating
            parts of identity information.
            </summary>
            <docgen category='Layout Options' order='50' />
        </member>
        <member name="P:NLog.LayoutRenderers.IdentityLayoutRenderer.Name">
            <summary>
            Gets or sets a value indicating whether to render Thread.CurrentPrincipal.Identity.Name.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.IdentityLayoutRenderer.AuthType">
            <summary>
            Gets or sets a value indicating whether to render Thread.CurrentPrincipal.Identity.AuthenticationType.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.IdentityLayoutRenderer.IsAuthenticated">
            <summary>
            Gets or sets a value indicating whether to render Thread.CurrentPrincipal.Identity.IsAuthenticated.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="M:NLog.LayoutRenderers.IdentityLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.InstallContextLayoutRenderer">
            <summary>
            Lookup parameter value from <see cref="P:NLog.Config.InstallationContext.Parameters"/>
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/InstallContext-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/InstallContext-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.InstallContextLayoutRenderer.Parameter">
            <summary>
            Gets or sets the name of the parameter.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="M:NLog.LayoutRenderers.InstallContextLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.LayoutRenderer">
            <summary>
            Render environmental information related to logging events.
            </summary>
        </member>
        <member name="P:NLog.LayoutRenderers.LayoutRenderer.LoggingConfiguration">
            <summary>
            Gets the logging configuration this target is part of.
            </summary>
        </member>
        <member name="P:NLog.LayoutRenderers.LayoutRenderer.ValueFormatter">
            <summary>
            Value formatter
            </summary>
        </member>
        <member name="M:NLog.LayoutRenderers.LayoutRenderer.ToString">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.LayoutRenderer.Render(NLog.LogEventInfo)">
            <summary>
            Renders the value of layout renderer in the context of the specified log event.
            </summary>
            <param name="logEvent">The log event.</param>
            <returns>String representation of a layout renderer.</returns>
        </member>
        <member name="M:NLog.LayoutRenderers.LayoutRenderer.NLog#Internal#ISupportsInitialize#Initialize(NLog.Config.LoggingConfiguration)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.LayoutRenderer.NLog#Internal#ISupportsInitialize#Close">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.LayoutRenderer.Initialize(NLog.Config.LoggingConfiguration)">
            <summary>
            Initializes this instance.
            </summary>
            <param name="configuration">The configuration.</param>
        </member>
        <member name="M:NLog.LayoutRenderers.LayoutRenderer.Close">
            <summary>
            Closes this instance.
            </summary>
        </member>
        <member name="M:NLog.LayoutRenderers.LayoutRenderer.RenderAppendBuilder(NLog.LogEventInfo,System.Text.StringBuilder)">
            <summary>
            Renders the value of layout renderer in the context of the specified log event.
            </summary>
            <param name="logEvent">The log event.</param>
            <param name="builder">The layout render output is appended to builder</param>
        </member>
        <member name="M:NLog.LayoutRenderers.LayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <summary>
            Renders the value of layout renderer in the context of the specified log event into <see cref="T:System.Text.StringBuilder" />.
            </summary>
            <param name="builder">The <see cref="T:System.Text.StringBuilder"/> to append the rendered data to.</param>
            <param name="logEvent">Logging event.</param>
        </member>
        <member name="M:NLog.LayoutRenderers.LayoutRenderer.InitializeLayoutRenderer">
            <summary>
            Initializes the layout renderer.
            </summary>
        </member>
        <member name="M:NLog.LayoutRenderers.LayoutRenderer.CloseLayoutRenderer">
            <summary>
            Closes the layout renderer.
            </summary>
        </member>
        <member name="M:NLog.LayoutRenderers.LayoutRenderer.GetFormatProvider(NLog.LogEventInfo,System.IFormatProvider)">
            <summary>
            Get the <see cref="T:System.IFormatProvider"/> for rendering the messages to a <see cref="T:System.String"/>
            </summary>
            <param name="logEvent">LogEvent with culture</param>
            <param name="layoutCulture">Culture in on Layout level</param>
            <returns></returns>
        </member>
        <member name="M:NLog.LayoutRenderers.LayoutRenderer.GetCulture(NLog.LogEventInfo,System.Globalization.CultureInfo)">
            <summary>
            Get the <see cref="T:System.Globalization.CultureInfo"/> for rendering the messages to a <see cref="T:System.String"/>
            </summary>
            <param name="logEvent">LogEvent with culture</param>
            <param name="layoutCulture">Culture in on Layout level</param>
            <returns></returns>
            <remarks>
            <see cref="M:NLog.LayoutRenderers.LayoutRenderer.GetFormatProvider(NLog.LogEventInfo,System.IFormatProvider)"/> is preferred
            </remarks>
        </member>
        <member name="M:NLog.LayoutRenderers.LayoutRenderer.Register``1(System.String)">
             <summary>
             Obsolete and replaced by <see cref="M:NLog.LogManager.Setup"/> with NLog v5.2.
            
             Register a custom layout renderer.
             </summary>
             <remarks>Short-cut for registering to default <see cref="T:NLog.Config.ConfigurationItemFactory"/></remarks>
             <typeparam name="T">Type of the layout renderer.</typeparam>
             <param name="name">The layout-renderer type-alias for use in NLog configuration - without '${ }'</param>
        </member>
        <member name="M:NLog.LayoutRenderers.LayoutRenderer.Register(System.String,System.Type)">
             <summary>
             Obsolete and replaced by <see cref="M:NLog.LogManager.Setup"/> with NLog v5.2.
            
             Register a custom layout renderer.
             </summary>
             <remarks>Short-cut for registering to default <see cref="T:NLog.Config.ConfigurationItemFactory"/></remarks>
             <param name="layoutRendererType"> Type of the layout renderer.</param>
             <param name="name">The layout-renderer type-alias for use in NLog configuration - without '${ }'</param>
        </member>
        <member name="M:NLog.LayoutRenderers.LayoutRenderer.Register(System.String,System.Func{NLog.LogEventInfo,System.Object})">
             <summary>
             Obsolete and replaced by <see cref="M:NLog.LogManager.Setup"/> with NLog v5.2.
            
             Register a custom layout renderer with a callback function <paramref name="func"/>. The callback receives the logEvent.
             </summary>
             <param name="name">The layout-renderer type-alias for use in NLog configuration - without '${ }'</param>
             <param name="func">Callback that returns the value for the layout renderer.</param>
        </member>
        <member name="M:NLog.LayoutRenderers.LayoutRenderer.Register(System.String,System.Func{NLog.LogEventInfo,NLog.Config.LoggingConfiguration,System.Object})">
             <summary>
             Obsolete and replaced by <see cref="M:NLog.LogManager.Setup"/> with NLog v5.2.
            
             Register a custom layout renderer with a callback function <paramref name="func"/>. The callback receives the logEvent and the current configuration.
             </summary>
             <param name="name">The layout-renderer type-alias for use in NLog configuration - without '${ }'</param>
             <param name="func">Callback that returns the value for the layout renderer.</param>
        </member>
        <member name="M:NLog.LayoutRenderers.LayoutRenderer.Register(NLog.LayoutRenderers.FuncLayoutRenderer)">
             <summary>
             Obsolete and replaced by <see cref="M:NLog.LogManager.Setup"/> with NLog v5.2.
            
             Register a custom layout renderer with a callback function <paramref name="layoutRenderer"/>. The callback receives the logEvent and the current configuration.
             </summary>
             <param name="layoutRenderer">Renderer with callback func</param>
        </member>
        <member name="M:NLog.LayoutRenderers.LayoutRenderer.ResolveService``1">
            <summary>
            Resolves the interface service-type from the service-repository
            </summary>
        </member>
        <member name="T:NLog.LayoutRenderers.LayoutRendererAttribute">
            <summary>
            Marks class as layout-renderer and attaches a type-alias name for use in NLog configuration.
            </summary>
        </member>
        <member name="M:NLog.LayoutRenderers.LayoutRendererAttribute.#ctor(System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.LayoutRendererAttribute" /> class.
            </summary>
            <param name="name">The layout-renderer type-alias for use in NLog configuration - without '${ }'</param>
        </member>
        <member name="T:NLog.LayoutRenderers.LevelFormat">
            <summary>
            Format of the ${level} layout renderer output.
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.LevelFormat.Name">
            <summary>
            Render the LogLevel standard name.
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.LevelFormat.FirstCharacter">
            <summary>
            Render the first character of the level.
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.LevelFormat.OneLetter">
            <summary>
            Render the first character of the level.
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.LevelFormat.Ordinal">
            <summary>
            Render the ordinal (aka number) for the level.
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.LevelFormat.FullName">
            <summary>
            Render the LogLevel full name, expanding Warn / Info abbreviations
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.LevelFormat.TriLetter">
            <summary>
            Render the LogLevel as 3 letter abbreviations (Trc, Dbg, Inf, Wrn, Err, Ftl)
            </summary>
        </member>
        <member name="T:NLog.LayoutRenderers.LevelLayoutRenderer">
            <summary>
            The log level.
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/Level-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/Level-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.LevelLayoutRenderer.Format">
            <summary>
            Gets or sets a value indicating the output format of the level.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.LevelLayoutRenderer.Uppercase">
            <summary>
            Gets or sets a value indicating whether upper case conversion should be applied.
            </summary>
            <value>A value of <c>true</c> if upper case conversion should be applied otherwise, <c>false</c>.</value>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="M:NLog.LayoutRenderers.LevelLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.LiteralLayoutRenderer">
             <summary>
             A string literal.
             </summary>
             <remarks>
             This is used to escape '${' sequence
             as ;${literal:text=${}'
            
             <a href="https://github.com/NLog/NLog/wiki/Literal-Layout-Renderer">See NLog Wiki</a>
             </remarks>
             <seealso href="https://github.com/NLog/NLog/wiki/Literal-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="M:NLog.LayoutRenderers.LiteralLayoutRenderer.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.LiteralLayoutRenderer" /> class.
            </summary>
        </member>
        <member name="M:NLog.LayoutRenderers.LiteralLayoutRenderer.#ctor(System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.LiteralLayoutRenderer" /> class.
            </summary>
            <param name="text">The literal text value.</param>
            <remarks>This is used by the layout compiler.</remarks>
        </member>
        <member name="P:NLog.LayoutRenderers.LiteralLayoutRenderer.Text">
            <summary>
            Gets or sets the literal text.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="M:NLog.LayoutRenderers.LiteralLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.LiteralWithRawValueLayoutRenderer">
            <summary>
            A string literal with a fixed raw value
            </summary>
        </member>
        <member name="M:NLog.LayoutRenderers.LiteralWithRawValueLayoutRenderer.#ctor(System.String,System.Boolean,System.Object)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.LiteralLayoutRenderer" /> class.
            </summary>
            <param name="text">The literal text value.</param>
            <param name="rawValueSuccess"></param>
            <param name="rawValue">Fixed raw value</param>
            <remarks>This is used by the layout compiler.</remarks>
        </member>
        <member name="T:NLog.LayoutRenderers.LocalIpAddressLayoutRenderer">
             <summary>
             The IP address from the network interface card (NIC) on the local machine
             </summary>
             <remarks>
             Skips loopback-adapters and tunnel-interfaces. Skips devices without any MAC-address
            
             <a href="https://github.com/NLog/NLog/wiki/Local-IP-Address-Layout-Renderer">See NLog Wiki</a>
             </remarks>
             <seealso href="https://github.com/NLog/NLog/wiki/Local-IP-Address-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.LocalIpAddressLayoutRenderer.AddressFamily">
            <summary>
            Get or set whether to prioritize IPv6 or IPv4 (default)
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="M:NLog.LayoutRenderers.LocalIpAddressLayoutRenderer.#ctor">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.LocalIpAddressLayoutRenderer.#ctor(NLog.Internal.INetworkInterfaceRetriever)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.LocalIpAddressLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer">
            <summary>
            XML event description compatible with log4j, Chainsaw and NLogViewer.
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/Log4JXMLEvent-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/Log4JXMLEvent-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="M:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer" /> class.
            </summary>
        </member>
        <member name="M:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer.#ctor(NLog.Internal.Fakeables.IAppEnvironment)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer" /> class.
            </summary>
        </member>
        <member name="M:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer.InitializeLayoutRenderer">
            <inheritdoc/>
        </member>
        <member name="P:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer.IncludeNLogData">
            <summary>
            Gets or sets a value indicating whether to include NLog-specific extensions to log4j schema.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer.IndentXml">
            <summary>
            Gets or sets a value indicating whether the XML should use spaces for indentation.
            </summary>
            <docgen category='Layout Options' order='50' />
        </member>
        <member name="P:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer.LoggerName">
            <summary>
            Gets or sets the log4j:event logger-xml-attribute. Default: ${logger}
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer.FormattedMessage">
            <summary>
            Gets or sets the log4j:event message-xml-element. Default: ${message}
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer.AppInfo">
            <summary>
            Gets or sets the log4j:event log4japp-xml-element. By default it's the friendly name of the current AppDomain.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer.IncludeCallSite">
            <summary>
            Gets or sets a value indicating whether to include call site (class and method name) in the information sent over the network.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer.IncludeSourceInfo">
            <summary>
            Gets or sets a value indicating whether to include source info (file name and line number) in the information sent over the network.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer.IncludeMdc">
             <summary>
             Obsolete and replaced by <see cref="P:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer.IncludeScopeProperties"/> with NLog v5.
            
             Gets or sets a value indicating whether to include contents of the <see cref="T:NLog.MappedDiagnosticsContext"/> dictionary.
             </summary>
             <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer.IncludeMdlc">
             <summary>
             Obsolete and replaced by <see cref="P:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer.IncludeScopeProperties"/> with NLog v5.
            
             Gets or sets a value indicating whether to include contents of the <see cref="T:NLog.MappedDiagnosticsLogicalContext"/> dictionary.
             </summary>
             <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer.IncludeNdlc">
             <summary>
             Obsolete and replaced by <see cref="P:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer.IncludeNdc"/> with NLog v5.
            
             Gets or sets a value indicating whether to include contents of the <see cref="T:NLog.NestedDiagnosticsLogicalContext"/> stack.
             </summary>
             <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer.IncludeNdc">
            <summary>
            Gets or sets whether to include log4j:NDC in output from <see cref="T:NLog.ScopeContext"/> nested context.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer.IncludeScopeProperties">
            <summary>
            Gets or sets whether to include the contents of the <see cref="T:NLog.ScopeContext"/> properties-dictionary.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer.IncludeScopeNested">
            <summary>
            Gets or sets whether to include log4j:NDC in output from <see cref="T:NLog.ScopeContext"/> nested context.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer.ScopeNestedSeparator">
            <summary>
            Gets or sets the stack separator for log4j:NDC in output from <see cref="T:NLog.ScopeContext"/> nested context.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer.NdlcItemSeparator">
             <summary>
             Obsolete and replaced by <see cref="P:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer.NdcItemSeparator"/> with NLog v5.
            
             Gets or sets the stack separator for log4j:NDC in output from <see cref="T:NLog.ScopeContext"/> nested context.
             </summary>
             <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer.IncludeAllProperties">
             <summary>
             Obsolete and replaced by <see cref="P:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer.IncludeEventProperties"/> with NLog v5.
            
             Gets or sets the option to include all properties from the log events
             </summary>
             <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer.IncludeEventProperties">
            <summary>
            Gets or sets the option to include all properties from the log events
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer.NdcItemSeparator">
            <summary>
            Gets or sets the stack separator for log4j:NDC in output from <see cref="T:NLog.ScopeContext"/> nested context.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer.WriteThrowableCData">
            <summary>
             Gets or sets whether the log4j:throwable xml-element should be written as CDATA
            </summary>
            <docgen category='Layout Options' order='50' />
        </member>
        <member name="P:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer.NLog#Config#IUsesStackTrace#StackTraceUsage">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.LoggerNameLayoutRenderer">
            <summary>
            The logger name.
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/Logger-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/Logger-Layout-Renderer">Documentation on NLog Wiki</seealso>///
        </member>
        <member name="P:NLog.LayoutRenderers.LoggerNameLayoutRenderer.ShortName">
            <summary>
            Gets or sets a value indicating whether to render short logger name (the part after the trailing dot character).
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.LoggerNameLayoutRenderer.PrefixName">
            <summary>
            Gets or sets a value indicating whether to render prefix of logger name (the part before the trailing dot character).
            </summary>
        </member>
        <member name="M:NLog.LayoutRenderers.LoggerNameLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.LongDateLayoutRenderer">
            <summary>
            The date and time in a long, sortable format yyyy-MM-dd HH:mm:ss.ffff.
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/LongDate-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/LongDate-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.LongDateLayoutRenderer.UniversalTime">
            <summary>
            Gets or sets a value indicating whether to output UTC time instead of local time.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="M:NLog.LayoutRenderers.LongDateLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.MachineNameLayoutRenderer">
            <summary>
            The machine name that the process is running on.
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/MachineName-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/MachineName-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="M:NLog.LayoutRenderers.MachineNameLayoutRenderer.InitializeLayoutRenderer">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.MachineNameLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.MdcLayoutRenderer">
            <summary>
            Obsolete and replaced by <see cref="T:NLog.LayoutRenderers.ScopeContextPropertyLayoutRenderer"/> with NLog v5.
            Render Mapped Diagnostics Logical (MDC) from <see cref="T:NLog.MappedDiagnosticsContext"/>
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/Mdc-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/Mdc-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.MdcLayoutRenderer.Item">
            <summary>
            Gets or sets the name of the item.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.MdcLayoutRenderer.Format">
            <summary>
            Format string for conversion from object to string.
            </summary>
            <docgen category='Layout Options' order='50' />
        </member>
        <member name="M:NLog.LayoutRenderers.MdcLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.MdlcLayoutRenderer">
            <summary>
            Obsolete and replaced by <see cref="T:NLog.LayoutRenderers.ScopeContextPropertyLayoutRenderer"/> with NLog v5.
            Render Mapped Diagnostics Logical Context (MDLC) from <see cref="T:NLog.MappedDiagnosticsLogicalContext"/>
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/Mdlc-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/Mdlc-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.MdlcLayoutRenderer.Item">
            <summary>
            Gets or sets the name of the item.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.MdlcLayoutRenderer.Format">
            <summary>
            Format string for conversion from object to string.
            </summary>
            <docgen category='Layout Options' order='50' />
        </member>
        <member name="M:NLog.LayoutRenderers.MdlcLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.MessageLayoutRenderer">
            <summary>
            The formatted log message.
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/Message-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/Message-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="M:NLog.LayoutRenderers.MessageLayoutRenderer.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.MessageLayoutRenderer" /> class.
            </summary>
        </member>
        <member name="P:NLog.LayoutRenderers.MessageLayoutRenderer.WithException">
            <summary>
            Gets or sets a value indicating whether to log exception along with message.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.MessageLayoutRenderer.ExceptionSeparator">
            <summary>
            Gets or sets the string that separates message from the exception.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.MessageLayoutRenderer.Raw">
            <summary>
            Gets or sets whether it should render the raw message without formatting parameters
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="M:NLog.LayoutRenderers.MessageLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.NdcLayoutRenderer">
            <summary>
            Obsolete and replaced by <see cref="T:NLog.LayoutRenderers.ScopeContextNestedStatesLayoutRenderer"/> with NLog v5.
            Render Nested Diagnostic Context (NDC) from <see cref="T:NLog.NestedDiagnosticsContext"/>
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/Ndc-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/Ndc-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.NdcLayoutRenderer.TopFrames">
            <summary>
            Gets or sets the number of top stack frames to be rendered.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.NdcLayoutRenderer.BottomFrames">
            <summary>
            Gets or sets the number of bottom stack frames to be rendered.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.NdcLayoutRenderer.Separator">
            <summary>
            Gets or sets the separator to be used for concatenating nested diagnostics context output.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="M:NLog.LayoutRenderers.NdcLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.NdlcLayoutRenderer">
            <summary>
            Obsolete and replaced by <see cref="T:NLog.LayoutRenderers.ScopeContextNestedStatesLayoutRenderer"/> with NLog v5.
            Render Nested Diagnostic Context (NDLC) from <see cref="T:NLog.NestedDiagnosticsLogicalContext"/>
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/Ndlc-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/Ndlc-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.NdlcLayoutRenderer.TopFrames">
            <summary>
            Gets or sets the number of top stack frames to be rendered.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.NdlcLayoutRenderer.BottomFrames">
            <summary>
            Gets or sets the number of bottom stack frames to be rendered.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.NdlcLayoutRenderer.Separator">
            <summary>
            Gets or sets the separator to be used for concatenating nested logical context output.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="M:NLog.LayoutRenderers.NdlcLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.NdlcTimingLayoutRenderer">
            <summary>
            Obsolete and replaced by <see cref="T:NLog.LayoutRenderers.ScopeContextTimingLayoutRenderer"/> with NLog v5.
            Render Nested Diagnostic Context (NDLC) timings from <see cref="T:NLog.NestedDiagnosticsLogicalContext"/>
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/NdlcTiming-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/NdlcTiming-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.NdlcTimingLayoutRenderer.CurrentScope">
            <summary>
            Gets or sets whether to only include the duration of the last scope created
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.NdlcTimingLayoutRenderer.ScopeBeginTime">
            <summary>
            Gets or sets whether to just display the scope creation time, and not the duration
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.NdlcTimingLayoutRenderer.Format">
            <summary>
            Gets or sets the TimeSpan format. Can be any argument accepted by TimeSpan.ToString(format).
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="M:NLog.LayoutRenderers.NdlcTimingLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.NewLineLayoutRenderer">
            <summary>
            A newline literal.
            </summary>
        </member>
        <member name="M:NLog.LayoutRenderers.NewLineLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.NLogDirLayoutRenderer">
            <summary>
            The directory where NLog.dll is located.
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/NLogDir-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/NLogDir-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.NLogDirLayoutRenderer.File">
            <summary>
            Gets or sets the name of the file to be Path.Combine()'d with the directory name.
            </summary>
            <docgen category='Advanced Options' order='50' />
        </member>
        <member name="P:NLog.LayoutRenderers.NLogDirLayoutRenderer.Dir">
            <summary>
            Gets or sets the name of the directory to be Path.Combine()'d with the directory name.
            </summary>
            <docgen category='Advanced Options' order='50' />
        </member>
        <member name="M:NLog.LayoutRenderers.NLogDirLayoutRenderer.InitializeLayoutRenderer">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.NLogDirLayoutRenderer.CloseLayoutRenderer">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.NLogDirLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.ProcessDirLayoutRenderer">
            <summary>
            The executable directory from the <see cref="P:System.Diagnostics.Process.MainModule"/> FileName,
            using the current process <see cref="M:System.Diagnostics.Process.GetCurrentProcess"/>
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/ProcessDir-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/ProcessDir-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.ProcessDirLayoutRenderer.File">
            <summary>
            Gets or sets the name of the file to be Path.Combine()'d with the process directory.
            </summary>
            <docgen category='Advanced Options' order='50' />
        </member>
        <member name="P:NLog.LayoutRenderers.ProcessDirLayoutRenderer.Dir">
            <summary>
            Gets or sets the name of the directory to be Path.Combine()'d with the process directory.
            </summary>
            <docgen category='Advanced Options' order='50' />
        </member>
        <member name="M:NLog.LayoutRenderers.ProcessDirLayoutRenderer.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.ProcessDirLayoutRenderer" /> class.
            </summary>
        </member>
        <member name="M:NLog.LayoutRenderers.ProcessDirLayoutRenderer.#ctor(NLog.Internal.Fakeables.IAppEnvironment)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.ProcessDirLayoutRenderer" /> class.
            </summary>
        </member>
        <member name="M:NLog.LayoutRenderers.ProcessDirLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.ProcessIdLayoutRenderer">
            <summary>
            The identifier of the current process.
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/ProcessId-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/ProcessId-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="M:NLog.LayoutRenderers.ProcessIdLayoutRenderer.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.ProcessIdLayoutRenderer" /> class.
            </summary>
        </member>
        <member name="M:NLog.LayoutRenderers.ProcessIdLayoutRenderer.#ctor(NLog.Internal.Fakeables.IAppEnvironment)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.ProcessIdLayoutRenderer" /> class.
            </summary>
        </member>
        <member name="M:NLog.LayoutRenderers.ProcessIdLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.ProcessInfoLayoutRenderer">
            <summary>
            The information about the running process.
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/ProcessInfo-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/ProcessInfo-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.ProcessInfoLayoutRenderer.Property">
            <summary>
            Gets or sets the property to retrieve.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.ProcessInfoLayoutRenderer.Format">
            <summary>
            Gets or sets the format-string to use if the property supports it (Ex. DateTime / TimeSpan / Enum)
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.ProcessInfoLayoutRenderer.Culture">
            <summary>
            Gets or sets the culture used for rendering.
            </summary>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="M:NLog.LayoutRenderers.ProcessInfoLayoutRenderer.InitializeLayoutRenderer">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.ProcessInfoLayoutRenderer.CloseLayoutRenderer">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.ProcessInfoLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.ProcessInfoProperty">
            <summary>
            Property of System.Diagnostics.Process to retrieve.
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.BasePriority">
            <summary>
            Base Priority.
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.ExitCode">
            <summary>
            Exit Code.
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.ExitTime">
            <summary>
            Exit Time.
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.Handle">
            <summary>
            Process Handle.
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.HandleCount">
            <summary>
            Handle Count.
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.HasExited">
            <summary>
            Whether process has exited.
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.Id">
            <summary>
            Process ID.
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.MachineName">
            <summary>
            Machine name.
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.MainWindowHandle">
            <summary>
            Handle of the main window.
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.MainWindowTitle">
            <summary>
            Title of the main window.
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.MaxWorkingSet">
            <summary>
            Maximum Working Set.
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.MinWorkingSet">
            <summary>
            Minimum Working Set.
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.NonPagedSystemMemorySize">
            <summary>
            Non-paged System Memory Size.
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.NonPagedSystemMemorySize64">
            <summary>
            Non-paged System Memory Size (64-bit).
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.PagedMemorySize">
            <summary>
            Paged Memory Size.
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.PagedMemorySize64">
            <summary>
            Paged Memory Size (64-bit)..
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.PagedSystemMemorySize">
            <summary>
            Paged System Memory Size.
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.PagedSystemMemorySize64">
            <summary>
            Paged System Memory Size (64-bit).
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.PeakPagedMemorySize">
            <summary>
            Peak Paged Memory Size.
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.PeakPagedMemorySize64">
            <summary>
            Peak Paged Memory Size (64-bit).
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.PeakVirtualMemorySize">
            <summary>
            Peak Virtual Memory Size.
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.PeakVirtualMemorySize64">
            <summary>
            Peak Virtual Memory Size (64-bit)..
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.PeakWorkingSet">
            <summary>
            Peak Working Set Size.
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.PeakWorkingSet64">
            <summary>
            Peak Working Set Size (64-bit).
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.PriorityBoostEnabled">
            <summary>
            Whether priority boost is enabled.
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.PriorityClass">
            <summary>
            Priority Class.
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.PrivateMemorySize">
            <summary>
            Private Memory Size.
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.PrivateMemorySize64">
            <summary>
            Private Memory Size (64-bit).
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.PrivilegedProcessorTime">
            <summary>
            Privileged Processor Time.
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.ProcessName">
            <summary>
            Process Name.
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.Responding">
            <summary>
            Whether process is responding.
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.SessionId">
            <summary>
            Session ID.
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.StartTime">
            <summary>
            Process Start Time.
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.TotalProcessorTime">
            <summary>
            Total Processor Time.
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.UserProcessorTime">
            <summary>
            User Processor Time.
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.VirtualMemorySize">
            <summary>
            Virtual Memory Size.
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.VirtualMemorySize64">
            <summary>
            Virtual Memory Size (64-bit).
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.WorkingSet">
            <summary>
            Working Set Size.
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.ProcessInfoProperty.WorkingSet64">
            <summary>
            Working Set Size (64-bit).
            </summary>
        </member>
        <member name="T:NLog.LayoutRenderers.ProcessNameLayoutRenderer">
            <summary>
            The name of the current process.
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/ProcessName-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/ProcessName-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.ProcessNameLayoutRenderer.FullName">
            <summary>
            Gets or sets a value indicating whether to write the full path to the process executable.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="M:NLog.LayoutRenderers.ProcessNameLayoutRenderer.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.ProcessNameLayoutRenderer" /> class.
            </summary>
        </member>
        <member name="M:NLog.LayoutRenderers.ProcessNameLayoutRenderer.#ctor(NLog.Internal.Fakeables.IAppEnvironment)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.ProcessNameLayoutRenderer" /> class.
            </summary>
        </member>
        <member name="M:NLog.LayoutRenderers.ProcessNameLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.ProcessTimeLayoutRenderer">
            <summary>
            The process time in format HH:mm:ss.mmm.
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/ProcessTime-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/ProcessTime-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.ProcessTimeLayoutRenderer.Invariant">
            <summary>
            Gets or sets a value indicating whether to output in culture invariant format
            </summary>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="P:NLog.LayoutRenderers.ProcessTimeLayoutRenderer.Culture">
            <summary>
            Gets or sets the culture used for rendering.
            </summary>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="M:NLog.LayoutRenderers.ProcessTimeLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.ProcessTimeLayoutRenderer.WriteTimestamp(System.Text.StringBuilder,System.TimeSpan,System.Globalization.CultureInfo)">
            <summary>
            Write timestamp to builder with format hh:mm:ss:fff
            </summary>
        </member>
        <member name="T:NLog.LayoutRenderers.ScopeContextIndentLayoutRenderer">
            <summary>
            Renders the nested states from <see cref="T:NLog.ScopeContext"/> like a callstack
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/ScopeIndent-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/ScopeIndent-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.ScopeContextIndentLayoutRenderer.Indent">
            <summary>
            Gets or sets the indent token.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="M:NLog.LayoutRenderers.ScopeContextIndentLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.ScopeContextNestedStatesLayoutRenderer">
            <summary>
            Renders the nested states from <see cref="T:NLog.ScopeContext"/> like a callstack
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/ScopeNested-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/ScopeNested-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.ScopeContextNestedStatesLayoutRenderer.TopFrames">
            <summary>
            Gets or sets the number of top stack frames to be rendered.
            </summary>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="P:NLog.LayoutRenderers.ScopeContextNestedStatesLayoutRenderer.BottomFrames">
            <summary>
            Gets or sets the number of bottom stack frames to be rendered.
            </summary>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="P:NLog.LayoutRenderers.ScopeContextNestedStatesLayoutRenderer.Separator">
            <summary>
            Gets or sets the separator to be used for concatenating nested logical context output.
            </summary>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="P:NLog.LayoutRenderers.ScopeContextNestedStatesLayoutRenderer.Format">
            <summary>
            Gets or sets how to format each nested state. Ex. like JSON = @
            </summary>
            <docgen category='Layout Options' order='50' />
        </member>
        <member name="P:NLog.LayoutRenderers.ScopeContextNestedStatesLayoutRenderer.Culture">
            <summary>
            Gets or sets the culture used for rendering.
            </summary>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="M:NLog.LayoutRenderers.ScopeContextNestedStatesLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.ScopeContextPropertyLayoutRenderer">
            <summary>
            Renders specified property-item from <see cref="T:NLog.ScopeContext"/>
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/ScopeProperty-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/ScopeProperty-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.ScopeContextPropertyLayoutRenderer.Item">
            <summary>
            Gets or sets the name of the item.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.ScopeContextPropertyLayoutRenderer.Format">
            <summary>
            Format string for conversion from object to string.
            </summary>
            <docgen category='Layout Options' order='50' />
        </member>
        <member name="P:NLog.LayoutRenderers.ScopeContextPropertyLayoutRenderer.Culture">
            <summary>
            Gets or sets the culture used for rendering.
            </summary>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="M:NLog.LayoutRenderers.ScopeContextPropertyLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.ScopeContextTimingLayoutRenderer">
            <summary>
            <see cref="T:NLog.ScopeContext"/> Timing Renderer (Async scope)
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/ScopeTiming-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/ScopeTiming-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.ScopeContextTimingLayoutRenderer.CurrentScope">
            <summary>
            Gets or sets whether to only include the duration of the last scope created
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.ScopeContextTimingLayoutRenderer.StartTime">
            <summary>
            Gets or sets whether to just display the scope creation time, and not the duration
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.ScopeContextTimingLayoutRenderer.Format">
             <summary>
             Gets or sets the TimeSpan format. Can be any argument accepted by TimeSpan.ToString(format).
            
             When Format has not been specified, then it will render TimeSpan.TotalMilliseconds
             </summary>
             <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.ScopeContextTimingLayoutRenderer.Culture">
            <summary>
            Gets or sets the culture used for rendering.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="M:NLog.LayoutRenderers.ScopeContextTimingLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.SequenceIdLayoutRenderer">
            <summary>
            The sequence ID
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/SequenceId-layout-renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/SequenceId-layout-renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="M:NLog.LayoutRenderers.SequenceIdLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.ShortDateLayoutRenderer">
            <summary>
            The short date in a sortable format yyyy-MM-dd.
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/ShortDate-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/ShortDate-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.ShortDateLayoutRenderer.UniversalTime">
            <summary>
            Gets or sets a value indicating whether to output UTC time instead of local time.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="M:NLog.LayoutRenderers.ShortDateLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.SpecialFolderApplicationDataLayoutRenderer">
            <summary>
            System special folder path from <see cref="F:System.Environment.SpecialFolder.ApplicationData"/>
            </summary>
        </member>
        <member name="M:NLog.LayoutRenderers.SpecialFolderApplicationDataLayoutRenderer.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.SpecialFolderApplicationDataLayoutRenderer" /> class.
            </summary>
        </member>
        <member name="T:NLog.LayoutRenderers.SpecialFolderCommonApplicationDataLayoutRenderer">
            <summary>
            System special folder path from <see cref="F:System.Environment.SpecialFolder.CommonApplicationData"/>
            </summary>
        </member>
        <member name="M:NLog.LayoutRenderers.SpecialFolderCommonApplicationDataLayoutRenderer.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.SpecialFolderCommonApplicationDataLayoutRenderer" /> class.
            </summary>
        </member>
        <member name="T:NLog.LayoutRenderers.SpecialFolderLayoutRenderer">
            <summary>
            System special folder path (includes My Documents, My Music, Program Files, Desktop, and more).
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/Special-Folder-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/Special-Folder-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.SpecialFolderLayoutRenderer.Folder">
            <summary>
            Gets or sets the system special folder to use.
            </summary>
            <remarks>
            Full list of options is available at <a href="https://docs.microsoft.com/en-us/dotnet/api/system.environment.specialfolder">MSDN</a>.
            The most common ones are:
            <ul>
            <li><b>CommonApplicationData</b> - application data for all users.</li>
            <li><b>ApplicationData</b> - roaming application data for current user.</li>
            <li><b>LocalApplicationData</b> - non roaming application data for current user</li>
            <li><b>UserProfile</b> - Profile folder for current user</li>
            <li><b>DesktopDirectory</b> - Desktop-directory for current user</li>
            <li><b>MyDocuments</b> - My Documents-directory for current user</li>
            <li><b>System</b> - System directory</li>
            </ul>
            </remarks>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.SpecialFolderLayoutRenderer.File">
            <summary>
            Gets or sets the name of the file to be Path.Combine()'d with the directory name.
            </summary>
            <docgen category='Advanced Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.SpecialFolderLayoutRenderer.Dir">
            <summary>
            Gets or sets the name of the directory to be Path.Combine()'d with the directory name.
            </summary>
            <docgen category='Advanced Options' order='10' />
        </member>
        <member name="M:NLog.LayoutRenderers.SpecialFolderLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.SpecialFolderLocalApplicationDataLayoutRenderer">
            <summary>
            System special folder path from <see cref="F:System.Environment.SpecialFolder.LocalApplicationData"/>
            </summary>
        </member>
        <member name="M:NLog.LayoutRenderers.SpecialFolderLocalApplicationDataLayoutRenderer.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.SpecialFolderLocalApplicationDataLayoutRenderer" /> class.
            </summary>
        </member>
        <member name="T:NLog.LayoutRenderers.StackTraceFormat">
            <summary>
            Format of the ${stacktrace} layout renderer output.
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.StackTraceFormat.Raw">
            <summary>
            Raw format (multiline - as returned by StackFrame.ToString() method).
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.StackTraceFormat.Flat">
            <summary>
            Flat format (class and method names displayed in a single line).
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.StackTraceFormat.DetailedFlat">
            <summary>
            Detailed flat format (method signatures displayed in a single line).
            </summary>
        </member>
        <member name="T:NLog.LayoutRenderers.StackTraceLayoutRenderer">
            <summary>
            Stack trace renderer.
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/Stack-Trace-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/Stack-Trace-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.StackTraceLayoutRenderer.Format">
            <summary>
            Gets or sets the output format of the stack trace.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.StackTraceLayoutRenderer.TopFrames">
            <summary>
            Gets or sets the number of top stack frames to be rendered.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.StackTraceLayoutRenderer.SkipFrames">
            <summary>
            Gets or sets the number of frames to skip.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.StackTraceLayoutRenderer.Separator">
            <summary>
            Gets or sets the stack frame separator string.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.StackTraceLayoutRenderer.CaptureStackTrace">
            <summary>
            Logger should capture StackTrace, if it was not provided manually
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.StackTraceLayoutRenderer.Reverse">
            <summary>
            Gets or sets whether to render StackFrames in reverse order
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.StackTraceLayoutRenderer.NLog#Config#IUsesStackTrace#StackTraceUsage">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.StackTraceLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.TempDirLayoutRenderer">
            <summary>
            A temporary directory.
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/TempDir-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/TempDir-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.TempDirLayoutRenderer.File">
            <summary>
            Gets or sets the name of the file to be Path.Combine()'d with the directory name.
            </summary>
            <docgen category='Advanced Options' order='50' />
        </member>
        <member name="P:NLog.LayoutRenderers.TempDirLayoutRenderer.Dir">
            <summary>
            Gets or sets the name of the directory to be Path.Combine()'d with the directory name.
            </summary>
            <docgen category='Advanced Options' order='50' />
        </member>
        <member name="M:NLog.LayoutRenderers.TempDirLayoutRenderer.InitializeLayoutRenderer">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.TempDirLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.ThreadIdLayoutRenderer">
            <summary>
            The identifier of the current thread.
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/ThreadId-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/ThreadId-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="M:NLog.LayoutRenderers.ThreadIdLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.ThreadNameLayoutRenderer">
            <summary>
            The name of the current thread.
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/ThreadName-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/ThreadName-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="M:NLog.LayoutRenderers.ThreadNameLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.TicksLayoutRenderer">
            <summary>
            The Ticks value of current date and time.
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/Ticks-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/Ticks-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="M:NLog.LayoutRenderers.TicksLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.TimeLayoutRenderer">
            <summary>
            The time in a 24-hour, sortable format HH:mm:ss.mmmm.
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/Time-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/Time-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.TimeLayoutRenderer.UniversalTime">
            <summary>
            Gets or sets a value indicating whether to output UTC time instead of local time.
            </summary>
            <docgen category='Layout Options' order='50' />
        </member>
        <member name="P:NLog.LayoutRenderers.TimeLayoutRenderer.Invariant">
            <summary>
            Gets or sets a value indicating whether to output in culture invariant format
            </summary>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="P:NLog.LayoutRenderers.TimeLayoutRenderer.Culture">
            <summary>
            Gets or sets the culture used for rendering.
            </summary>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="M:NLog.LayoutRenderers.TimeLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.TraceActivityIdLayoutRenderer">
            <summary>
            A renderer that puts into log a System.Diagnostics trace correlation id.
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/Trace-Activity-Id-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/Trace-Activity-Id-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="M:NLog.LayoutRenderers.TraceActivityIdLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.VariableLayoutRenderer">
            <summary>
            Render a NLog Configuration variable assigned from API or loaded from config-file
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/Var-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/Var-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.VariableLayoutRenderer.Name">
            <summary>
            Gets or sets the name of the NLog variable.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.VariableLayoutRenderer.Default">
            <summary>
            Gets or sets the default value to be used when the variable is not set.
            </summary>
            <remarks>Not used if Name is <c>null</c></remarks>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.VariableLayoutRenderer.ActiveLayout">
            <summary>
            Gets the configuration variable layout matching the configured Name
            </summary>
            <remarks>Mostly relevant for the scanning of active NLog Layouts (Ex. CallSite capture)</remarks>
        </member>
        <member name="M:NLog.LayoutRenderers.VariableLayoutRenderer.InitializeLayoutRenderer">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.VariableLayoutRenderer.TryGetLayout(NLog.Layouts.Layout@)">
            <summary>
            Try lookup the configuration variable layout matching the configured Name
            </summary>
        </member>
        <member name="M:NLog.LayoutRenderers.VariableLayoutRenderer.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.Wrappers.CachedLayoutRendererWrapper">
             <summary>
             Applies caching to another layout output.
             </summary>
             <remarks>
             The value of the inner layout will be rendered only once and reused subsequently.
            
             <a href="https://github.com/NLog/NLog/wiki/Cached-Layout-Renderer">See NLog Wiki</a>
             </remarks>
             <seealso href="https://github.com/NLog/NLog/wiki/Cached-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="T:NLog.LayoutRenderers.Wrappers.CachedLayoutRendererWrapper.ClearCacheOption">
            <summary>
            A value indicating when the cache is cleared.
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.Wrappers.CachedLayoutRendererWrapper.ClearCacheOption.None">
            <summary>Never clear the cache.</summary>
        </member>
        <member name="F:NLog.LayoutRenderers.Wrappers.CachedLayoutRendererWrapper.ClearCacheOption.OnInit">
            <summary>Clear the cache whenever the <see cref="T:NLog.LayoutRenderers.Wrappers.CachedLayoutRendererWrapper"/> is initialized.</summary>
        </member>
        <member name="F:NLog.LayoutRenderers.Wrappers.CachedLayoutRendererWrapper.ClearCacheOption.OnClose">
            <summary>Clear the cache whenever the <see cref="T:NLog.LayoutRenderers.Wrappers.CachedLayoutRendererWrapper"/> is closed.</summary>
        </member>
        <member name="P:NLog.LayoutRenderers.Wrappers.CachedLayoutRendererWrapper.Cached">
            <summary>
            Gets or sets a value indicating whether this <see cref="T:NLog.LayoutRenderers.Wrappers.CachedLayoutRendererWrapper"/> is enabled.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.Wrappers.CachedLayoutRendererWrapper.ClearCache">
            <summary>
            Gets or sets a value indicating when the cache is cleared.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.Wrappers.CachedLayoutRendererWrapper.CacheKey">
            <summary>
            Cachekey. If the cachekey changes, resets the value. For example, the cachekey would be the current day.s
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.Wrappers.CachedLayoutRendererWrapper.CachedSeconds">
            <summary>
            Gets or sets a value indicating how many seconds the value should stay cached until it expires
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.CachedLayoutRendererWrapper.InitializeLayoutRenderer">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.CachedLayoutRendererWrapper.CloseLayoutRenderer">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.CachedLayoutRendererWrapper.Transform(System.String)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.CachedLayoutRendererWrapper.RenderInner(NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.Wrappers.FileSystemNormalizeLayoutRendererWrapper">
            <summary>
            Filters characters not allowed in the file names by replacing them with safe character.
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/Filesystem-Normalize-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/Filesystem-Normalize-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.Wrappers.FileSystemNormalizeLayoutRendererWrapper.FSNormalize">
            <summary>
            Gets or sets a value indicating whether to modify the output of this renderer so it can be used as a part of file path
            (illegal characters are replaced with '_').
            </summary>
            <docgen category='Advanced Options' order='50' />
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.FileSystemNormalizeLayoutRendererWrapper.RenderInnerAndTransform(NLog.LogEventInfo,System.Text.StringBuilder,System.Int32)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.FileSystemNormalizeLayoutRendererWrapper.Transform(System.String)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.Wrappers.JsonEncodeLayoutRendererWrapper">
            <summary>
            Escapes output of another layout using JSON rules.
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/Json-Encode-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/Json-Encode-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.Wrappers.JsonEncodeLayoutRendererWrapper.JsonEncode">
            <summary>
            Gets or sets whether output should be encoded with Json-string escaping.
            </summary>
            <docgen category="Layout Options" order="10"/>
        </member>
        <member name="P:NLog.LayoutRenderers.Wrappers.JsonEncodeLayoutRendererWrapper.EscapeUnicode">
            <summary>
            Gets or sets a value indicating whether to escape non-ascii characters
            </summary>
            <docgen category="Layout Options" order="10"/>
        </member>
        <member name="P:NLog.LayoutRenderers.Wrappers.JsonEncodeLayoutRendererWrapper.EscapeForwardSlash">
            <summary>
            Should forward slashes be escaped? If true, / will be converted to \/
            </summary>
            <remarks>
            If not set explicitly then the value of the parent will be used as default.
            </remarks>
            <docgen category="Layout Options" order="10"/>
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.JsonEncodeLayoutRendererWrapper.RenderInnerAndTransform(NLog.LogEventInfo,System.Text.StringBuilder,System.Int32)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.JsonEncodeLayoutRendererWrapper.Transform(System.String)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.Wrappers.LeftLayoutRendererWrapper">
            <summary>
            Left part of a text
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/Left-layout-renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/Left-layout-renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.Wrappers.LeftLayoutRendererWrapper.Length">
            <summary>
            Gets or sets the length in characters.
            </summary>
            <docgen category="Layout Options" order="10"/>
        </member>
        <member name="P:NLog.LayoutRenderers.Wrappers.LeftLayoutRendererWrapper.Truncate">
            <summary>
            Same as <see cref="P:NLog.LayoutRenderers.Wrappers.LeftLayoutRendererWrapper.Length"/>-property, so it can be used as ambient property.
            </summary>
            <example>
            ${message:truncate=80}
            </example>
            <docgen category="Layout Options" order="10"/>
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.LeftLayoutRendererWrapper.RenderInnerAndTransform(NLog.LogEventInfo,System.Text.StringBuilder,System.Int32)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.LeftLayoutRendererWrapper.Transform(System.String)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.Wrappers.LowercaseLayoutRendererWrapper">
            <summary>
            Converts the result of another layout output to lower case.
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/Lowercase-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/Lowercase-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.Wrappers.LowercaseLayoutRendererWrapper.Lowercase">
            <summary>
            Gets or sets a value indicating whether lower case conversion should be applied.
            </summary>
            <value>A value of <c>true</c> if lower case conversion should be applied; otherwise, <c>false</c>.</value>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.Wrappers.LowercaseLayoutRendererWrapper.ToLower">
            <summary>
            Same as <see cref="P:NLog.LayoutRenderers.Wrappers.LowercaseLayoutRendererWrapper.Lowercase"/>-property, so it can be used as ambient property.
            </summary>
            <example>
            ${level:tolower}
            </example>
            <docgen category="Layout Options" order="10"/>
        </member>
        <member name="P:NLog.LayoutRenderers.Wrappers.LowercaseLayoutRendererWrapper.Culture">
            <summary>
            Gets or sets the culture used for rendering.
            </summary>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.LowercaseLayoutRendererWrapper.RenderInnerAndTransform(NLog.LogEventInfo,System.Text.StringBuilder,System.Int32)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.LowercaseLayoutRendererWrapper.Transform(System.String)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.Wrappers.NoRawValueLayoutRendererWrapper">
            <summary>
            Render the non-raw value of an object.
            </summary>
            <remarks>For performance and/or full (formatted) control of the output.</remarks>
        </member>
        <member name="P:NLog.LayoutRenderers.Wrappers.NoRawValueLayoutRendererWrapper.NoRawValue">
            <summary>
            Gets or sets a value indicating whether to disable the IRawValue-interface
            </summary>
            <value>A value of <c>true</c> if IRawValue-interface should be ignored; otherwise, <c>false</c>.</value>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.NoRawValueLayoutRendererWrapper.RenderInnerAndTransform(NLog.LogEventInfo,System.Text.StringBuilder,System.Int32)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.NoRawValueLayoutRendererWrapper.Transform(System.String)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.Wrappers.ObjectPathRendererWrapper">
            <summary>
            Render a single property of a object
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/ObjectPath-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/ObjectPath-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.Wrappers.ObjectPathRendererWrapper.Path">
             <summary>
             Gets or sets the object-property-navigation-path for lookup of nested property
            
             Shortcut for <see cref="P:NLog.LayoutRenderers.Wrappers.ObjectPathRendererWrapper.ObjectPath"/>
             </summary>
             <docgen category="Layout Options" order="10"/>
        </member>
        <member name="P:NLog.LayoutRenderers.Wrappers.ObjectPathRendererWrapper.ObjectPath">
            <summary>
            Gets or sets the object-property-navigation-path for lookup of nested property
            </summary>
            <docgen category="Layout Options" order="10"/>
        </member>
        <member name="P:NLog.LayoutRenderers.Wrappers.ObjectPathRendererWrapper.Format">
            <summary>
            Format string for conversion from object to string.
            </summary>
            <docgen category="Layout Options" order="100"/>
        </member>
        <member name="P:NLog.LayoutRenderers.Wrappers.ObjectPathRendererWrapper.Culture">
            <summary>
            Gets or sets the culture used for rendering.
            </summary>
            <docgen category="Layout Options" order="100"/>
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.ObjectPathRendererWrapper.Transform(System.String)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.ObjectPathRendererWrapper.RenderInnerAndTransform(NLog.LogEventInfo,System.Text.StringBuilder,System.Int32)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.ObjectPathRendererWrapper.TryGetPropertyValue(System.Object,System.Object@)">
            <summary>
            Lookup property-value from source object based on <see cref="P:NLog.LayoutRenderers.Wrappers.ObjectPathRendererWrapper.ObjectPath"/>
            </summary>
            <returns>Could resolve property-value?</returns>
        </member>
        <member name="T:NLog.LayoutRenderers.Wrappers.OnExceptionLayoutRendererWrapper">
            <summary>
            Only outputs the inner layout when exception has been defined for log message.
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/OnException-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/OnException-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.Wrappers.OnExceptionLayoutRendererWrapper.Else">
            <summary>
            If <see cref="P:NLog.LogEventInfo.Exception"/> is not found, print this layout.
            </summary>
            <docgen category="Condition Options" order="10"/>
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.OnExceptionLayoutRendererWrapper.RenderInnerAndTransform(NLog.LogEventInfo,System.Text.StringBuilder,System.Int32)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.OnExceptionLayoutRendererWrapper.Transform(System.String)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.Wrappers.OnHasPropertiesLayoutRendererWrapper">
            <summary>
            Outputs alternative layout when the inner layout produces empty result.
            </summary>
            <example>
            ${onhasproperties:, Properties\: ${all-event-properties}}
            </example>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/OnHasProperties-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/OnHasProperties-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.Wrappers.OnHasPropertiesLayoutRendererWrapper.Else">
            <summary>
            If <see cref="P:NLog.LogEventInfo.HasProperties"/> is not found, print this layout.
            </summary>
            <docgen category="Condition Options" order="10"/>
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.OnHasPropertiesLayoutRendererWrapper.RenderInnerAndTransform(NLog.LogEventInfo,System.Text.StringBuilder,System.Int32)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.OnHasPropertiesLayoutRendererWrapper.Transform(System.String)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.Wrappers.PaddingHorizontalAlignment">
            <summary>
            Horizontal alignment for padding layout renderers.
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.Wrappers.PaddingHorizontalAlignment.Left">
            <summary>
            When layout text is too long, align it to the left
            (remove characters from the right).
            </summary>
        </member>
        <member name="F:NLog.LayoutRenderers.Wrappers.PaddingHorizontalAlignment.Right">
            <summary>
            When layout text is too long, align it to the right
            (remove characters from the left).
            </summary>
        </member>
        <member name="T:NLog.LayoutRenderers.Wrappers.PaddingLayoutRendererWrapper">
            <summary>
            Applies padding to another layout output.
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/Pad-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/Pad-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.Wrappers.PaddingLayoutRendererWrapper.Padding">
            <summary>
            Gets or sets the number of characters to pad the output to.
            </summary>
            <remarks>
            Positive padding values cause left padding, negative values
            cause right padding to the desired width.
            </remarks>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.Wrappers.PaddingLayoutRendererWrapper.PadCharacter">
            <summary>
            Gets or sets the padding character.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.Wrappers.PaddingLayoutRendererWrapper.FixedLength">
            <summary>
            Gets or sets a value indicating whether to trim the
            rendered text to the absolute value of the padding length.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.Wrappers.PaddingLayoutRendererWrapper.AlignmentOnTruncation">
            <summary>
            Gets or sets a value indicating whether a value that has
            been truncated (when <see cref="P:NLog.LayoutRenderers.Wrappers.PaddingLayoutRendererWrapper.FixedLength" /> is true)
            will be left-aligned (characters removed from the right)
            or right-aligned (characters removed from the left). The
            default is left alignment.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.PaddingLayoutRendererWrapper.RenderInnerAndTransform(NLog.LogEventInfo,System.Text.StringBuilder,System.Int32)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.PaddingLayoutRendererWrapper.Transform(System.String)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.Wrappers.ReplaceLayoutRendererWrapper">
            <summary>
            Replaces a string in the output of another layout with another string.
            </summary>
            <example>
            ${replace:searchFor=\\n+:replaceWith=-:regex=true:inner=${message}}
            </example>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/Replace-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/Replace-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.Wrappers.ReplaceLayoutRendererWrapper.SearchFor">
            <summary>
            Gets or sets the text to search for.
            </summary>
            <value>The text search for.</value>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.Wrappers.ReplaceLayoutRendererWrapper.Regex">
            <summary>
            Gets or sets a value indicating whether regular expressions should be used.
            </summary>
            <value>A value of <c>true</c> if regular expressions should be used otherwise, <c>false</c>.</value>
            <docgen category='Condition Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.Wrappers.ReplaceLayoutRendererWrapper.ReplaceWith">
            <summary>
            Gets or sets the replacement string.
            </summary>
            <value>The replacement string.</value>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.Wrappers.ReplaceLayoutRendererWrapper.ReplaceGroupName">
            <summary>
            Gets or sets the group name to replace when using regular expressions.
            Leave null or empty to replace without using group name.
            </summary>
            <value>The group name.</value>
            <docgen category='Condition Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.Wrappers.ReplaceLayoutRendererWrapper.IgnoreCase">
            <summary>
            Gets or sets a value indicating whether to ignore case.
            </summary>
            <value>A value of <c>true</c> if case should be ignored when searching; otherwise, <c>false</c>.</value>
            <docgen category='Condition Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.Wrappers.ReplaceLayoutRendererWrapper.WholeWords">
            <summary>
            Gets or sets a value indicating whether to search for whole words.
            </summary>
            <value>A value of <c>true</c> if whole words should be searched for; otherwise, <c>false</c>.</value>
            <docgen category='Condition Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.Wrappers.ReplaceLayoutRendererWrapper.CompileRegex">
            <summary>
            Compile the <see cref="P:NLog.LayoutRenderers.Wrappers.ReplaceLayoutRendererWrapper.Regex"/>? This can improve the performance, but at the costs of more memory usage. If <c>false</c>, the Regex Cache is used.
            </summary>
            <docgen category='Condition Options' order='10' />
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.ReplaceLayoutRendererWrapper.InitializeLayoutRenderer">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.ReplaceLayoutRendererWrapper.Transform(System.String)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.Wrappers.ReplaceLayoutRendererWrapper.Replacer">
            <summary>
            This class was created instead of simply using a lambda expression so that the "ThreadAgnosticAttributeTest" will pass
            </summary>
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.ReplaceLayoutRendererWrapper.ReplaceNamedGroup(System.String,System.String,System.String,System.Text.RegularExpressions.Match)">
            <summary>
            A match evaluator for Regular Expression based replacing
            </summary>
            <param name="input">Input string.</param>
            <param name="groupName">Group name in the regex.</param>
            <param name="replacement">Replace value.</param>
            <param name="match">Match from regex.</param>
            <returns>Groups replaced with <paramref name="replacement"/>.</returns>
        </member>
        <member name="T:NLog.LayoutRenderers.Wrappers.ReplaceNewLinesLayoutRendererWrapper">
            <summary>
            Replaces newline characters from the result of another layout renderer with spaces.
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/Replace-NewLines-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/Replace-NewLines-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.Wrappers.ReplaceNewLinesLayoutRendererWrapper.Replacement">
            <summary>
            Gets or sets a value indicating the string that should be used for separating lines.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.ReplaceNewLinesLayoutRendererWrapper.RenderInnerAndTransform(NLog.LogEventInfo,System.Text.StringBuilder,System.Int32)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.ReplaceNewLinesLayoutRendererWrapper.Transform(System.String)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.Wrappers.RightLayoutRendererWrapper">
            <summary>
            Right part of a text
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/Right-layout-renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/Right-layout-renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.Wrappers.RightLayoutRendererWrapper.Length">
            <summary>
            Gets or sets the length in characters.
            </summary>
            <docgen category="Layout Options" order="10"/>
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.RightLayoutRendererWrapper.RenderInnerAndTransform(NLog.LogEventInfo,System.Text.StringBuilder,System.Int32)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.RightLayoutRendererWrapper.Transform(System.String)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.Wrappers.Rot13LayoutRendererWrapper">
             <summary>
             Decodes text "encrypted" with ROT-13.
             </summary>
             <remarks>
             See <a href="https://en.wikipedia.org/wiki/ROT13">https://en.wikipedia.org/wiki/ROT13</a>.
            
             <a href="https://github.com/NLog/NLog/wiki/Rot13-Layout-Renderer">See NLog Wiki</a>
             </remarks>
             <seealso href="https://github.com/NLog/NLog/wiki/Rot13-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.Wrappers.Rot13LayoutRendererWrapper.Text">
            <summary>
            Gets or sets the layout to be wrapped.
            </summary>
            <value>The layout to be wrapped.</value>
            <remarks>This variable is for backwards compatibility</remarks>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.Rot13LayoutRendererWrapper.DecodeRot13(System.String)">
            <summary>
            Encodes/Decodes ROT-13-encoded string.
            </summary>
            <param name="encodedValue">The string to be encoded/decoded.</param>
            <returns>Encoded/Decoded text.</returns>
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.Rot13LayoutRendererWrapper.RenderInnerAndTransform(NLog.LogEventInfo,System.Text.StringBuilder,System.Int32)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.Rot13LayoutRendererWrapper.Transform(System.String)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.Rot13LayoutRendererWrapper.DecodeRot13(System.Text.StringBuilder,System.Int32)">
            <summary>
            Encodes/Decodes ROT-13-encoded string.
            </summary>
        </member>
        <member name="T:NLog.LayoutRenderers.Wrappers.SubstringLayoutRendererWrapper">
            <summary>
            Substring the result
            </summary>
            <example>
            ${substring:${level}:start=2:length=2}
            ${substring:${level}:start=-2:length=2}
            ${substring:Inner=${level}:start=2:length=2}
            </example>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/Substring-layout-renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/Substring-layout-renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.Wrappers.SubstringLayoutRendererWrapper.Start">
            <summary>
            Gets or sets the start index.
            </summary>
            <value>Index</value>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.Wrappers.SubstringLayoutRendererWrapper.Length">
            <summary>
            Gets or sets the length in characters. If <c>null</c>, then the whole string
            </summary>
            <value>Index</value>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.SubstringLayoutRendererWrapper.RenderInnerAndTransform(NLog.LogEventInfo,System.Text.StringBuilder,System.Int32)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.SubstringLayoutRendererWrapper.Transform(System.String)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.SubstringLayoutRendererWrapper.CalcStart(System.Int32)">
            <summary>
            Calculate start position
            </summary>
            <returns>0 or positive number</returns>
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.SubstringLayoutRendererWrapper.CalcLength(System.Int32,System.Int32)">
            <summary>
            Calculate needed length
            </summary>
            <returns>0 or positive number</returns>
        </member>
        <member name="T:NLog.LayoutRenderers.Wrappers.TrimWhiteSpaceLayoutRendererWrapper">
            <summary>
            Trims the whitespace from the result of another layout renderer.
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/Trim-Whitespace-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/Trim-Whitespace-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.Wrappers.TrimWhiteSpaceLayoutRendererWrapper.TrimWhiteSpace">
            <summary>
            Gets or sets a value indicating whether lower case conversion should be applied.
            </summary>
            <value>A value of <c>true</c> if lower case conversion should be applied; otherwise, <c>false</c>.</value>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.TrimWhiteSpaceLayoutRendererWrapper.RenderInnerAndTransform(NLog.LogEventInfo,System.Text.StringBuilder,System.Int32)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.TrimWhiteSpaceLayoutRendererWrapper.Transform(System.String)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.Wrappers.UppercaseLayoutRendererWrapper">
            <summary>
            Converts the result of another layout output to upper case.
            </summary>
            <example>
            ${uppercase:${level}} //[DefaultParameter]
            ${uppercase:Inner=${level}}
            ${level:uppercase} // [AmbientProperty]
            </example>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/Uppercase-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/Uppercase-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.Wrappers.UppercaseLayoutRendererWrapper.Uppercase">
            <summary>
            Gets or sets a value indicating whether upper case conversion should be applied.
            </summary>
            <value>A value of <c>true</c> if upper case conversion should be applied otherwise, <c>false</c>.</value>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.Wrappers.UppercaseLayoutRendererWrapper.ToUpper">
            <summary>
            Same as <see cref="P:NLog.LayoutRenderers.Wrappers.UppercaseLayoutRendererWrapper.Uppercase"/>-property, so it can be used as ambient property.
            </summary>
            <example>
            ${level:toupper}
            </example>
            <docgen category="Layout Options" order="10"/>
        </member>
        <member name="P:NLog.LayoutRenderers.Wrappers.UppercaseLayoutRendererWrapper.Culture">
            <summary>
            Gets or sets the culture used for rendering.
            </summary>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.UppercaseLayoutRendererWrapper.RenderInnerAndTransform(NLog.LogEventInfo,System.Text.StringBuilder,System.Int32)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.UppercaseLayoutRendererWrapper.Transform(System.String)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.Wrappers.UrlEncodeLayoutRendererWrapper">
            <summary>
            Encodes the result of another layout output for use with URLs.
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/Url-Encode-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/Url-Encode-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.UrlEncodeLayoutRendererWrapper.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.LayoutRenderers.Wrappers.UrlEncodeLayoutRendererWrapper" /> class.
            </summary>
        </member>
        <member name="P:NLog.LayoutRenderers.Wrappers.UrlEncodeLayoutRendererWrapper.SpaceAsPlus">
            <summary>
            Gets or sets a value indicating whether spaces should be translated to '+' or '%20'.
            </summary>
            <value>A value of <c>true</c> if space should be translated to '+'; otherwise, <c>false</c>.</value>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.LayoutRenderers.Wrappers.UrlEncodeLayoutRendererWrapper.EscapeDataRfc3986">
            <summary>
            Gets or sets a value whether escaping be done according to Rfc3986 (Supports Internationalized Resource Identifiers - IRIs)
            </summary>
            <value>A value of <c>true</c> if Rfc3986; otherwise, <c>false</c> for legacy Rfc2396.</value>
            <docgen category='Layout Options' order='50' />
        </member>
        <member name="P:NLog.LayoutRenderers.Wrappers.UrlEncodeLayoutRendererWrapper.EscapeDataNLogLegacy">
            <summary>
            Gets or sets a value whether escaping be done according to the old NLog style (Very non-standard)
            </summary>
            <value>A value of <c>true</c> if legacy encoding; otherwise, <c>false</c> for standard UTF8 encoding.</value>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.UrlEncodeLayoutRendererWrapper.Transform(System.String)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.UrlEncodeLayoutRendererWrapper.RenderInnerAndTransform(NLog.LogEventInfo,System.Text.StringBuilder,System.Int32)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.Wrappers.WhenEmptyLayoutRendererWrapper">
            <summary>
            Outputs alternative layout when the inner layout produces empty result.
            </summary>
        </member>
        <member name="P:NLog.LayoutRenderers.Wrappers.WhenEmptyLayoutRendererWrapper.WhenEmpty">
            <summary>
            Gets or sets the layout to be rendered when original layout produced empty result.
            </summary>
            <docgen category="Layout Options" order="10"/>
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.WhenEmptyLayoutRendererWrapper.InitializeLayoutRenderer">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.WhenEmptyLayoutRendererWrapper.RenderInnerAndTransform(NLog.LogEventInfo,System.Text.StringBuilder,System.Int32)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.WhenEmptyLayoutRendererWrapper.Transform(System.String)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.Wrappers.WhenLayoutRendererWrapper">
            <summary>
            Only outputs the inner layout when the specified condition has been met.
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/When-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/When-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.Wrappers.WhenLayoutRendererWrapper.When">
            <summary>
            Gets or sets the condition that must be met for the <see cref="P:NLog.LayoutRenderers.Wrappers.WrapperLayoutRendererBase.Inner"/> layout to be printed.
            </summary>
            <docgen category="Condition Options" order="10"/>
        </member>
        <member name="P:NLog.LayoutRenderers.Wrappers.WhenLayoutRendererWrapper.Else">
            <summary>
            If <see cref="P:NLog.LayoutRenderers.Wrappers.WhenLayoutRendererWrapper.When"/> is not met, print this layout.
            </summary>
            <docgen category="Condition Options" order="10"/>
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.WhenLayoutRendererWrapper.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.WhenLayoutRendererWrapper.Transform(System.String)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.Wrappers.WrapLineLayoutRendererWrapper">
            <summary>
            Replaces newline characters from the result of another layout renderer with spaces.
            </summary>
        </member>
        <member name="P:NLog.LayoutRenderers.Wrappers.WrapLineLayoutRendererWrapper.WrapLine">
            <summary>
            Gets or sets the line length for wrapping.
            </summary>
            <remarks>
            Only positive values are allowed
            </remarks>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.WrapLineLayoutRendererWrapper.Transform(System.String)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.Wrappers.WrapperLayoutRendererBase">
             <summary>
             Base class for <see cref="T:NLog.LayoutRenderers.LayoutRenderer"/>s which wrapping other <see cref="T:NLog.LayoutRenderers.LayoutRenderer"/>s.
            
             This has the <see cref="P:NLog.LayoutRenderers.Wrappers.WrapperLayoutRendererBase.Inner"/> property (which is default) and can be used to wrap.
             </summary>
             <example>
             ${uppercase:${level}} //[DefaultParameter]
             ${uppercase:Inner=${level}}
             </example>
        </member>
        <member name="P:NLog.LayoutRenderers.Wrappers.WrapperLayoutRendererBase.Inner">
             <summary>
             Gets or sets the wrapped layout.
            
             [DefaultParameter] so Inner: is not required if it's the first
             </summary>
             <docgen category='Layout Options' order='10' />
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.WrapperLayoutRendererBase.InitializeLayoutRenderer">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.WrapperLayoutRendererBase.Append(System.Text.StringBuilder,NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.WrapperLayoutRendererBase.RenderInnerAndTransform(NLog.LogEventInfo,System.Text.StringBuilder,System.Int32)">
            <summary>
            Appends the rendered output from <see cref="P:NLog.LayoutRenderers.Wrappers.WrapperLayoutRendererBase.Inner"/>-layout and transforms the added output (when necessary)
            </summary>
            <param name="logEvent">Logging event.</param>
            <param name="builder">The <see cref="T:System.Text.StringBuilder"/> to append the rendered data to.</param>
            <param name="orgLength">Start position for any necessary transformation of <see cref="T:System.Text.StringBuilder"/>.</param>
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.WrapperLayoutRendererBase.Transform(NLog.LogEventInfo,System.String)">
            <summary>
            Transforms the output of another layout.
            </summary>
            <param name="logEvent">Logging event.</param>
            <param name="text">Output to be transform.</param>
            <returns>Transformed text.</returns>
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.WrapperLayoutRendererBase.Transform(System.String)">
            <summary>
            Transforms the output of another layout.
            </summary>
            <param name="text">Output to be transform.</param>
            <returns>Transformed text.</returns>
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.WrapperLayoutRendererBase.RenderInner(NLog.LogEventInfo)">
            <summary>
            Renders the inner layout contents.
            </summary>
            <param name="logEvent">The log event.</param>
            <returns>Contents of inner layout.</returns>
        </member>
        <member name="T:NLog.LayoutRenderers.Wrappers.WrapperLayoutRendererBuilderBase">
             <summary>
             Base class for <see cref="T:NLog.LayoutRenderers.LayoutRenderer"/>s which wrapping other <see cref="T:NLog.LayoutRenderers.LayoutRenderer"/>s.
            
             This expects the transformation to work on a <see cref="T:System.Text.StringBuilder"/>
             </summary>
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.WrapperLayoutRendererBuilderBase.RenderInnerAndTransform(NLog.LogEventInfo,System.Text.StringBuilder,System.Int32)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.WrapperLayoutRendererBuilderBase.TransformFormattedMesssage(NLog.LogEventInfo,System.Text.StringBuilder)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.WrapperLayoutRendererBuilderBase.TransformFormattedMesssage(System.Text.StringBuilder)">
            <summary>
            Transforms the output of another layout.
            </summary>
            <param name="target">Output to be transform.</param>
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.WrapperLayoutRendererBuilderBase.RenderFormattedMessage(NLog.LogEventInfo,System.Text.StringBuilder)">
            <summary>
            Renders the inner layout contents.
            </summary>
            <param name="logEvent"></param>
            <param name="target"><see cref="T:System.Text.StringBuilder"/> for the result</param>
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.WrapperLayoutRendererBuilderBase.Transform(System.String)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.WrapperLayoutRendererBuilderBase.RenderInner(NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LayoutRenderers.Wrappers.XmlEncodeLayoutRendererWrapper">
            <summary>
            Converts the result of another layout output to be XML-compliant.
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/Xml-Encode-Layout-Renderer">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/Xml-Encode-Layout-Renderer">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.LayoutRenderers.Wrappers.XmlEncodeLayoutRendererWrapper.XmlEncode">
            <summary>
            Gets or sets whether output should be encoded with Xml-string escaping.
            </summary>
            <remarks>Ensures always valid XML, but gives a performance hit</remarks>
            <docgen category="Layout Options" order="10"/>
        </member>
        <member name="P:NLog.LayoutRenderers.Wrappers.XmlEncodeLayoutRendererWrapper.XmlEncodeNewlines">
            <summary>
            Gets or sets a value indicating whether to transform newlines (\r\n) into (&#13;&#10;)
            </summary>
            <docgen category="Layout Options" order="10"/>
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.XmlEncodeLayoutRendererWrapper.RenderInnerAndTransform(NLog.LogEventInfo,System.Text.StringBuilder,System.Int32)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LayoutRenderers.Wrappers.XmlEncodeLayoutRendererWrapper.Transform(System.String)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.Layouts.CompoundLayout">
            <summary>
            A layout containing one or more nested layouts.
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/CompoundLayout">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/CompoundLayout">Documentation on NLog Wiki</seealso>
        </member>
        <member name="M:NLog.Layouts.CompoundLayout.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Layouts.CompoundLayout"/> class.
            </summary>
        </member>
        <member name="P:NLog.Layouts.CompoundLayout.Layouts">
            <summary>
            Gets the inner layouts.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="M:NLog.Layouts.CompoundLayout.InitializeLayout">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Layouts.CompoundLayout.GetFormattedMessage(NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Layouts.CompoundLayout.RenderFormattedMessage(NLog.LogEventInfo,System.Text.StringBuilder)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Layouts.CompoundLayout.CloseLayout">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Layouts.CompoundLayout.ToString">
            <inheritdoc/>
        </member>
        <member name="T:NLog.Layouts.CsvColumn">
            <summary>
            A column in the CSV.
            </summary>
        </member>
        <member name="M:NLog.Layouts.CsvColumn.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Layouts.CsvColumn" /> class.
            </summary>
        </member>
        <member name="M:NLog.Layouts.CsvColumn.#ctor(System.String,NLog.Layouts.Layout)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Layouts.CsvColumn" /> class.
            </summary>
            <param name="name">The name of the column.</param>
            <param name="layout">The layout of the column.</param>
        </member>
        <member name="P:NLog.Layouts.CsvColumn.Name">
            <summary>
            Gets or sets the name of the column.
            </summary>
            <docgen category='Layout Options' order='1' />
        </member>
        <member name="P:NLog.Layouts.CsvColumn.Layout">
            <summary>
            Gets or sets the layout of the column.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Layouts.CsvColumn.Quoting">
            <summary>
            Gets or sets the override of Quoting mode
            </summary>
            <remarks>
            <see cref="F:NLog.Layouts.CsvQuotingMode.All"/> and <see cref="F:NLog.Layouts.CsvQuotingMode.Nothing"/> are faster than the default <see cref="F:NLog.Layouts.CsvQuotingMode.Auto"/>
            </remarks>
            <docgen category='Layout Options' order='50' />
        </member>
        <member name="T:NLog.Layouts.CsvColumnDelimiterMode">
            <summary>
            Specifies allowed column delimiters.
            </summary>
        </member>
        <member name="F:NLog.Layouts.CsvColumnDelimiterMode.Auto">
            <summary>
            Automatically detect from regional settings.
            </summary>
        </member>
        <member name="F:NLog.Layouts.CsvColumnDelimiterMode.Comma">
            <summary>
            Comma (ASCII 44).
            </summary>
        </member>
        <member name="F:NLog.Layouts.CsvColumnDelimiterMode.Semicolon">
            <summary>
            Semicolon (ASCII 59).
            </summary>
        </member>
        <member name="F:NLog.Layouts.CsvColumnDelimiterMode.Tab">
            <summary>
            Tab character (ASCII 9).
            </summary>
        </member>
        <member name="F:NLog.Layouts.CsvColumnDelimiterMode.Pipe">
            <summary>
            Pipe character (ASCII 124).
            </summary>
        </member>
        <member name="F:NLog.Layouts.CsvColumnDelimiterMode.Space">
            <summary>
            Space character (ASCII 32).
            </summary>
        </member>
        <member name="F:NLog.Layouts.CsvColumnDelimiterMode.Custom">
            <summary>
            Custom string, specified by the <see cref="P:NLog.Layouts.CsvLayout.CustomColumnDelimiter"/>.
            </summary>
        </member>
        <member name="T:NLog.Layouts.CsvLayout">
            <summary>
            A specialized layout that renders CSV-formatted events.
            </summary>
            <remarks>
            <para>
            If <see cref="P:NLog.Layouts.LayoutWithHeaderAndFooter.Header"/> is set, then the header generation with column names will be disabled.
            </para>
            <a href="https://github.com/NLog/NLog/wiki/CsvLayout">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/CsvLayout">Documentation on NLog Wiki</seealso>
        </member>
        <member name="M:NLog.Layouts.CsvLayout.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Layouts.CsvLayout"/> class.
            </summary>
        </member>
        <member name="P:NLog.Layouts.CsvLayout.Columns">
            <summary>
            Gets the array of parameters to be passed.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Layouts.CsvLayout.WithHeader">
            <summary>
            Gets or sets a value indicating whether CVS should include header.
            </summary>
            <value>A value of <c>true</c> if CVS should include header; otherwise, <c>false</c>.</value>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Layouts.CsvLayout.Delimiter">
            <summary>
            Gets or sets the column delimiter.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Layouts.CsvLayout.Quoting">
            <summary>
            Gets or sets the quoting mode.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Layouts.CsvLayout.QuoteChar">
            <summary>
            Gets or sets the quote Character.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Layouts.CsvLayout.CustomColumnDelimiter">
            <summary>
            Gets or sets the custom column delimiter value (valid when <see cref="P:NLog.Layouts.CsvLayout.Delimiter"/> is set to <see cref="F:NLog.Layouts.CsvColumnDelimiterMode.Custom"/>).
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="M:NLog.Layouts.CsvLayout.InitializeLayout">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Layouts.CsvLayout.CloseLayout">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Layouts.CsvLayout.GetFormattedMessage(NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Layouts.CsvLayout.RenderFormattedMessage(NLog.LogEventInfo,System.Text.StringBuilder)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Layouts.CsvLayout.RenderHeader(System.Text.StringBuilder)">
            <summary>
            Get the headers with the column names.
            </summary>
            <returns></returns>
        </member>
        <member name="T:NLog.Layouts.CsvLayout.CsvHeaderLayout">
            <summary>
            Header with column names for CSV layout.
            </summary>
        </member>
        <member name="M:NLog.Layouts.CsvLayout.CsvHeaderLayout.#ctor(NLog.Layouts.CsvLayout)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Layouts.CsvLayout.CsvHeaderLayout"/> class.
            </summary>
            <param name="parent">The parent.</param>
        </member>
        <member name="M:NLog.Layouts.CsvLayout.CsvHeaderLayout.InitializeLayout">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Layouts.CsvLayout.CsvHeaderLayout.GetFormattedMessage(NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Layouts.CsvLayout.CsvHeaderLayout.RenderFormattedMessage(NLog.LogEventInfo,System.Text.StringBuilder)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Layouts.CsvLayout.ToString">
            <inheritdoc/>
        </member>
        <member name="T:NLog.Layouts.CsvQuotingMode">
            <summary>
            Specifies CSV quoting modes.
            </summary>
        </member>
        <member name="F:NLog.Layouts.CsvQuotingMode.All">
            <summary>
            Quote Always (Fast)
            </summary>
        </member>
        <member name="F:NLog.Layouts.CsvQuotingMode.Nothing">
            <summary>
            Quote nothing (Very fast)
            </summary>
        </member>
        <member name="F:NLog.Layouts.CsvQuotingMode.Auto">
            <summary>
            Quote only whose values contain the quote symbol or the separator (Slow)
            </summary>
        </member>
        <member name="T:NLog.Layouts.JsonArrayLayout">
            <summary>
            A specialized layout that renders LogEvent as JSON-Array
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/JsonArrayLayout">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/JsonArrayLayout">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.Layouts.JsonArrayLayout.Items">
            <summary>
            Gets the array of items to include in JSON-Array
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Layouts.JsonArrayLayout.SuppressSpaces">
            <summary>
            Gets or sets the option to suppress the extra spaces in the output json
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Layouts.JsonArrayLayout.RenderEmptyObject">
            <summary>
            Gets or sets the option to render the empty object value {}
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="M:NLog.Layouts.JsonArrayLayout.InitializeLayout">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Layouts.JsonArrayLayout.CloseLayout">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Layouts.JsonArrayLayout.RenderFormattedMessage(NLog.LogEventInfo,System.Text.StringBuilder)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Layouts.JsonArrayLayout.GetFormattedMessage(NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Layouts.JsonArrayLayout.ToString">
            <inheritdoc/>
        </member>
        <member name="T:NLog.Layouts.JsonAttribute">
            <summary>
            JSON attribute.
            </summary>
        </member>
        <member name="M:NLog.Layouts.JsonAttribute.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Layouts.JsonAttribute" /> class.
            </summary>
        </member>
        <member name="M:NLog.Layouts.JsonAttribute.#ctor(System.String,NLog.Layouts.Layout)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Layouts.JsonAttribute" /> class.
            </summary>
            <param name="name">The name of the attribute.</param>
            <param name="layout">The layout of the attribute's value.</param>
        </member>
        <member name="M:NLog.Layouts.JsonAttribute.#ctor(System.String,NLog.Layouts.Layout,System.Boolean)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Layouts.JsonAttribute" /> class.
            </summary>
            <param name="name">The name of the attribute.</param>
            <param name="layout">The layout of the attribute's value.</param>
            <param name="encode">Encode value with json-encode</param>
        </member>
        <member name="P:NLog.Layouts.JsonAttribute.Name">
            <summary>
            Gets or sets the name of the attribute.
            </summary>
            <docgen category='Layout Options' order='1' />
        </member>
        <member name="P:NLog.Layouts.JsonAttribute.Layout">
            <summary>
            Gets or sets the layout that will be rendered as the attribute's value.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Layouts.JsonAttribute.ValueType">
            <summary>
            Gets or sets the result value type, for conversion of layout rendering output
            </summary>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="P:NLog.Layouts.JsonAttribute.DefaultValue">
            <summary>
            Gets or sets the fallback value when result value is not available
            </summary>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="P:NLog.Layouts.JsonAttribute.Encode">
            <summary>
            Gets or sets whether output should be encoded as Json-String-Property, or be treated as valid json.
            </summary>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="P:NLog.Layouts.JsonAttribute.EscapeUnicode">
            <summary>
            Gets or sets a value indicating whether to escape non-ascii characters
            </summary>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="P:NLog.Layouts.JsonAttribute.EscapeForwardSlash">
            <summary>
            Should forward slashes be escaped? If true, / will be converted to \/
            </summary>
            <remarks>
            If not set explicitly then the value of the parent will be used as default.
            </remarks>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="P:NLog.Layouts.JsonAttribute.IncludeEmptyValue">
            <summary>
            Gets or sets whether an attribute with empty value should be included in the output
            </summary>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="T:NLog.Layouts.JsonLayout">
            <summary>
            A specialized layout that renders JSON-formatted events.
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/JsonLayout">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/JsonLayout">Documentation on NLog Wiki</seealso>
        </member>
        <member name="M:NLog.Layouts.JsonLayout.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Layouts.JsonLayout"/> class.
            </summary>
        </member>
        <member name="P:NLog.Layouts.JsonLayout.Attributes">
            <summary>
            Gets the array of attributes' configurations.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Layouts.JsonLayout.SuppressSpaces">
            <summary>
            Gets or sets the option to suppress the extra spaces in the output json
            </summary>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="P:NLog.Layouts.JsonLayout.RenderEmptyObject">
            <summary>
            Gets or sets the option to render the empty object value {}
            </summary>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="P:NLog.Layouts.JsonLayout.IndentJson">
            <summary>
            Auto indent and create new lines
            </summary>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="P:NLog.Layouts.JsonLayout.IncludeEventProperties">
            <summary>
            Gets or sets the option to include all properties from the log event (as JSON)
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Layouts.JsonLayout.IncludeGdc">
            <summary>
            Gets or sets a value indicating whether to include contents of the <see cref="T:NLog.GlobalDiagnosticsContext"/> dictionary.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Layouts.JsonLayout.IncludeScopeProperties">
            <summary>
            Gets or sets whether to include the contents of the <see cref="T:NLog.ScopeContext"/> dictionary.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Layouts.JsonLayout.IncludeAllProperties">
             <summary>
             Obsolete and replaced by <see cref="P:NLog.Layouts.JsonLayout.IncludeEventProperties"/> with NLog v5.
            
             Gets or sets the option to include all properties from the log event (as JSON)
             </summary>
             <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Layouts.JsonLayout.IncludeMdc">
             <summary>
             Obsolete and replaced by <see cref="P:NLog.Layouts.JsonLayout.IncludeScopeProperties"/> with NLog v5.
            
             Gets or sets a value indicating whether to include contents of the <see cref="T:NLog.MappedDiagnosticsContext"/> dictionary.
             </summary>
             <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Layouts.JsonLayout.IncludeMdlc">
             <summary>
             Obsolete and replaced by <see cref="P:NLog.Layouts.JsonLayout.IncludeScopeProperties"/> with NLog v5.
            
             Gets or sets a value indicating whether to include contents of the <see cref="T:NLog.MappedDiagnosticsLogicalContext"/> dictionary.
             </summary>
             <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Layouts.JsonLayout.ExcludeEmptyProperties">
            <summary>
            Gets or sets the option to exclude null/empty properties from the log event (as JSON)
            </summary>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="P:NLog.Layouts.JsonLayout.ExcludeProperties">
            <summary>
            List of property names to exclude when <see cref="P:NLog.Layouts.JsonLayout.IncludeAllProperties"/> is true
            </summary>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="P:NLog.Layouts.JsonLayout.MaxRecursionLimit">
            <summary>
            How far should the JSON serializer follow object references before backing off
            </summary>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="P:NLog.Layouts.JsonLayout.EscapeForwardSlash">
            <summary>
            Should forward slashes be escaped? If true, / will be converted to \/
            </summary>
            <remarks>
            If not set explicitly then the value of the parent will be used as default.
            </remarks>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="M:NLog.Layouts.JsonLayout.InitializeLayout">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Layouts.JsonLayout.CloseLayout">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Layouts.JsonLayout.RenderFormattedMessage(NLog.LogEventInfo,System.Text.StringBuilder)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Layouts.JsonLayout.GetFormattedMessage(NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Layouts.JsonLayout.ToString">
            <inheritdoc/>
        </member>
        <member name="T:NLog.Layouts.Layout">
            <summary>
            Abstract interface that layouts must implement.
            </summary>
        </member>
        <member name="F:NLog.Layouts.Layout.IsInitialized">
            <summary>
            Is this layout initialized? See <see cref="M:NLog.Layouts.Layout.Initialize(NLog.Config.LoggingConfiguration)"/>
            </summary>
        </member>
        <member name="P:NLog.Layouts.Layout.ThreadAgnostic">
             <summary>
             Gets a value indicating whether this layout is thread-agnostic (can be rendered on any thread).
             </summary>
             <remarks>
             Layout is thread-agnostic if it has been marked with [ThreadAgnostic] attribute and all its children are
             like that as well.
            
             Thread-agnostic layouts only use contents of <see cref="T:NLog.LogEventInfo"/> for its output.
             </remarks>
        </member>
        <member name="P:NLog.Layouts.Layout.StackTraceUsage">
            <summary>
            Gets the level of stack trace information required for rendering.
            </summary>
        </member>
        <member name="P:NLog.Layouts.Layout.LoggingConfiguration">
            <summary>
            Gets the logging configuration this target is part of.
            </summary>
        </member>
        <member name="M:NLog.Layouts.Layout.op_Implicit(System.String)~NLog.Layouts.Layout">
            <summary>
            Converts a given text to a <see cref="T:NLog.Layouts.Layout" />.
            </summary>
            <param name="text">Text to be converted.</param>
            <returns><see cref="T:NLog.Layouts.SimpleLayout"/> object represented by the text.</returns>
        </member>
        <member name="M:NLog.Layouts.Layout.FromString(System.String)">
            <summary>
            Implicitly converts the specified string to a <see cref="T:NLog.Layouts.SimpleLayout"/>.
            </summary>
            <param name="layoutText">The layout string.</param>
            <returns>Instance of <see cref="T:NLog.Layouts.SimpleLayout"/>.</returns>'
        </member>
        <member name="M:NLog.Layouts.Layout.FromString(System.String,NLog.Config.ConfigurationItemFactory)">
            <summary>
            Implicitly converts the specified string to a <see cref="T:NLog.Layouts.SimpleLayout"/>.
            </summary>
            <param name="layoutText">The layout string.</param>
            <param name="configurationItemFactory">The NLog factories to use when resolving layout renderers.</param>
            <returns>Instance of <see cref="T:NLog.Layouts.SimpleLayout"/>.</returns>
        </member>
        <member name="M:NLog.Layouts.Layout.FromString(System.String,System.Boolean)">
            <summary>
            Implicitly converts the specified string to a <see cref="T:NLog.Layouts.SimpleLayout"/>.
            </summary>
            <param name="layoutText">The layout string.</param>
            <param name="throwConfigExceptions">Whether <see cref="T:NLog.NLogConfigurationException"/> should be thrown on parse errors (false = replace unrecognized tokens with a space).</param>
            <returns>Instance of <see cref="T:NLog.Layouts.SimpleLayout"/>.</returns>
        </member>
        <member name="M:NLog.Layouts.Layout.FromMethod(System.Func{NLog.LogEventInfo,System.Object},NLog.Layouts.LayoutRenderOptions)">
            <summary>
            Create a <see cref="T:NLog.Layouts.SimpleLayout"/> from a lambda method.
            </summary>
            <param name="layoutMethod">Method that renders the layout.</param>
            <param name="options">Whether method is ThreadAgnostic and doesn't depend on context of the logging application thread.</param>
            <returns>Instance of <see cref="T:NLog.Layouts.SimpleLayout"/>.</returns>
        </member>
        <member name="M:NLog.Layouts.Layout.Precalculate(NLog.LogEventInfo)">
             <summary>
             Precalculates the layout for the specified log event and stores the result
             in per-log event cache.
            
             Only if the layout doesn't have [ThreadAgnostic] and doesn't contain layouts with [ThreadAgnostic].
             </summary>
             <param name="logEvent">The log event.</param>
             <remarks>
             Calling this method enables you to store the log event in a buffer
             and/or potentially evaluate it in another thread even though the
             layout may contain thread-dependent renderer.
             </remarks>
        </member>
        <member name="M:NLog.Layouts.Layout.Render(NLog.LogEventInfo)">
            <summary>
            Renders formatted output using the log event as context.
            </summary>
            <remarks>Inside a <see cref="T:NLog.Targets.Target"/>, <see cref="M:NLog.Targets.Target.RenderLogEvent(NLog.Layouts.Layout,NLog.LogEventInfo)"/> is preferred for performance reasons.</remarks>
            <param name="logEvent">The logging event.</param>
            <returns>The formatted output as string.</returns>
        </member>
        <member name="M:NLog.Layouts.Layout.Render(NLog.LogEventInfo,System.Text.StringBuilder)">
            <summary>
            Optimized version of <see cref="M:NLog.Layouts.Layout.Render(NLog.LogEventInfo)"/> that works best when
            override of <see cref="M:NLog.Layouts.Layout.RenderFormattedMessage(NLog.LogEventInfo,System.Text.StringBuilder)"/> is available.
            </summary>
            <param name="logEvent">The logging event.</param>
            <param name="target">Appends the formatted output to target</param>
        </member>
        <member name="M:NLog.Layouts.Layout.RenderAppendBuilder(NLog.LogEventInfo,System.Text.StringBuilder,System.Boolean)">
            <summary>
            Optimized version of <see cref="M:NLog.Layouts.Layout.Render(NLog.LogEventInfo)"/> that works best when
            override of <see cref="M:NLog.Layouts.Layout.RenderFormattedMessage(NLog.LogEventInfo,System.Text.StringBuilder)"/> is available.
            </summary>
            <param name="logEvent">The logging event.</param>
            <param name="target">Appends the string representing log event to target</param>
            <param name="cacheLayoutResult">Should rendering result be cached on LogEventInfo</param>
        </member>
        <member name="M:NLog.Layouts.Layout.RenderAllocateBuilder(NLog.LogEventInfo)">
            <summary>
            Valid default implementation of <see cref="M:NLog.Layouts.Layout.GetFormattedMessage(NLog.LogEventInfo)" />, when having implemented the optimized <see cref="M:NLog.Layouts.Layout.RenderFormattedMessage(NLog.LogEventInfo,System.Text.StringBuilder)"/>
            </summary>
            <param name="logEvent">The logging event.</param>
            <returns>The rendered layout.</returns>
        </member>
        <member name="M:NLog.Layouts.Layout.RenderFormattedMessage(NLog.LogEventInfo,System.Text.StringBuilder)">
            <summary>
            Renders formatted output using the log event as context.
            </summary>
            <param name="logEvent">The logging event.</param>
            <param name="target">Appends the formatted output to target</param>
        </member>
        <member name="M:NLog.Layouts.Layout.NLog#Internal#ISupportsInitialize#Initialize(NLog.Config.LoggingConfiguration)">
            <summary>
            Initializes this instance.
            </summary>
            <param name="configuration">The configuration.</param>
        </member>
        <member name="M:NLog.Layouts.Layout.NLog#Internal#ISupportsInitialize#Close">
            <summary>
            Closes this instance.
            </summary>
        </member>
        <member name="M:NLog.Layouts.Layout.Initialize(NLog.Config.LoggingConfiguration)">
            <summary>
            Initializes this instance.
            </summary>
            <param name="configuration">The configuration.</param>
        </member>
        <member name="M:NLog.Layouts.Layout.Close">
            <summary>
            Closes this instance.
            </summary>
        </member>
        <member name="M:NLog.Layouts.Layout.InitializeLayout">
            <summary>
            Initializes the layout.
            </summary>
        </member>
        <member name="M:NLog.Layouts.Layout.CloseLayout">
            <summary>
            Closes the layout.
            </summary>
        </member>
        <member name="M:NLog.Layouts.Layout.GetFormattedMessage(NLog.LogEventInfo)">
            <summary>
            Renders formatted output using the log event as context.
            </summary>
            <param name="logEvent">The logging event.</param>
            <returns>The formatted output.</returns>
        </member>
        <member name="M:NLog.Layouts.Layout.Register``1(System.String)">
             <summary>
             Obsolete and replaced by <see cref="M:NLog.LogManager.Setup"/> with NLog v5.2.
            
             Register a custom Layout.
             </summary>
             <remarks>Short-cut for registering to default <see cref="T:NLog.Config.ConfigurationItemFactory"/></remarks>
             <typeparam name="T"> Type of the Layout.</typeparam>
             <param name="name"> Name of the Layout.</param>
        </member>
        <member name="M:NLog.Layouts.Layout.Register(System.String,System.Type)">
             <summary>
             Obsolete and replaced by <see cref="M:NLog.LogManager.Setup"/> with NLog v5.2.
            
             Register a custom Layout.
             </summary>
             <remarks>Short-cut for registering to default <see cref="T:NLog.Config.ConfigurationItemFactory"/></remarks>
             <param name="layoutType"> Type of the Layout.</param>
             <param name="name"> Name of the Layout.</param>
        </member>
        <member name="M:NLog.Layouts.Layout.PrecalculateBuilderInternal(NLog.LogEventInfo,System.Text.StringBuilder,NLog.Layouts.Layout[])">
            <summary>
            Optimized version of <see cref="M:NLog.Layouts.Layout.Precalculate(NLog.LogEventInfo)"/> for internal Layouts, when
            override of <see cref="M:NLog.Layouts.Layout.RenderFormattedMessage(NLog.LogEventInfo,System.Text.StringBuilder)"/> is available.
            </summary>
        </member>
        <member name="M:NLog.Layouts.Layout.TryGetRawValue(NLog.LogEventInfo,System.Object@)">
            <summary>
            Try get value
            </summary>
            <param name="logEvent"></param>
            <param name="rawValue">rawValue if return result is true</param>
            <returns>false if we could not determine the rawValue</returns>
        </member>
        <member name="M:NLog.Layouts.Layout.ResolveService``1">
            <summary>
            Resolve from DI <see cref="P:NLog.LogFactory.ServiceRepository"/>
            </summary>
            <remarks>Avoid calling this while handling a LogEvent, since random deadlocks can occur</remarks>
        </member>
        <member name="T:NLog.Layouts.LayoutAttribute">
            <summary>
            Marks class as Layout and attaches a type-alias name for use in NLog configuration.
            </summary>
        </member>
        <member name="M:NLog.Layouts.LayoutAttribute.#ctor(System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Layouts.LayoutAttribute" /> class.
            </summary>
            <param name="name">The Layout type-alias for use in NLog configuration.</param>
        </member>
        <member name="T:NLog.Layouts.LayoutParser">
            <summary>
            Parses layout strings.
            </summary>
        </member>
        <member name="M:NLog.Layouts.LayoutParser.AddLiteral(System.Text.StringBuilder,System.Collections.Generic.List{NLog.LayoutRenderers.LayoutRenderer})">
            <summary>
            Add <see cref="T:NLog.LayoutRenderers.LiteralLayoutRenderer"/> to <paramref name="result"/>
            </summary>
            <param name="literalBuf"></param>
            <param name="result"></param>
        </member>
        <member name="T:NLog.Layouts.LayoutRenderOptions">
            <summary>
            Options available for <see cref="M:NLog.Layouts.Layout.FromMethod(System.Func{NLog.LogEventInfo,System.Object},NLog.Layouts.LayoutRenderOptions)"/>
            </summary>
        </member>
        <member name="F:NLog.Layouts.LayoutRenderOptions.None">
            <summary>
            Default options
            </summary>
        </member>
        <member name="F:NLog.Layouts.LayoutRenderOptions.ThreadSafe">
            <summary>
            Layout renderer method can handle concurrent threads
            </summary>
        </member>
        <member name="F:NLog.Layouts.LayoutRenderOptions.ThreadAgnostic">
            <summary>
            Layout renderer method is agnostic to current thread context. This means it will render the same result independent of thread-context.
            </summary>
        </member>
        <member name="T:NLog.Layouts.LayoutWithHeaderAndFooter">
            <summary>
            A specialized layout that supports header and footer.
            </summary>
        </member>
        <member name="P:NLog.Layouts.LayoutWithHeaderAndFooter.Layout">
            <summary>
            Gets or sets the body layout (can be repeated multiple times).
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Layouts.LayoutWithHeaderAndFooter.Header">
            <summary>
            Gets or sets the header layout.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Layouts.LayoutWithHeaderAndFooter.Footer">
            <summary>
            Gets or sets the footer layout.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="M:NLog.Layouts.LayoutWithHeaderAndFooter.GetFormattedMessage(NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Layouts.LayoutWithHeaderAndFooter.RenderFormattedMessage(NLog.LogEventInfo,System.Text.StringBuilder)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.Layouts.Log4JXmlEventLayout">
            <summary>
            A specialized layout that renders Log4j-compatible XML events.
            </summary>
            <remarks>
            <para>
            This layout is not meant to be used explicitly. Instead you can use ${log4jxmlevent} layout renderer.
            </para>
            <a href="https://github.com/NLog/NLog/wiki/Log4JXmlEventLayout">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/Log4JXmlEventLayout">Documentation on NLog Wiki</seealso>
        </member>
        <member name="M:NLog.Layouts.Log4JXmlEventLayout.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Layouts.Log4JXmlEventLayout" /> class.
            </summary>
        </member>
        <member name="P:NLog.Layouts.Log4JXmlEventLayout.Renderer">
            <summary>
            Gets the <see cref="T:NLog.LayoutRenderers.Log4JXmlEventLayoutRenderer"/> instance that renders log events.
            </summary>
        </member>
        <member name="P:NLog.Layouts.Log4JXmlEventLayout.Parameters">
            <summary>
            Gets the collection of parameters. Each parameter contains a mapping
            between NLog layout and a named parameter.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Layouts.Log4JXmlEventLayout.IncludeEventProperties">
            <summary>
            Gets or sets the option to include all properties from the log events
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Layouts.Log4JXmlEventLayout.IncludeScopeProperties">
            <summary>
            Gets or sets whether to include the contents of the <see cref="T:NLog.ScopeContext"/> properties-dictionary.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Layouts.Log4JXmlEventLayout.IncludeScopeNested">
            <summary>
            Gets or sets whether to include log4j:NDC in output from <see cref="T:NLog.ScopeContext"/> nested context.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Layouts.Log4JXmlEventLayout.IncludeAllProperties">
             <summary>
             Obsolete and replaced by <see cref="P:NLog.Layouts.Log4JXmlEventLayout.IncludeEventProperties"/> with NLog v5.
            
             Gets or sets the option to include all properties from the log events
             </summary>
             <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Layouts.Log4JXmlEventLayout.IncludeMdc">
             <summary>
             Obsolete and replaced by <see cref="P:NLog.Layouts.Log4JXmlEventLayout.IncludeScopeProperties"/> with NLog v5.
            
             Gets or sets a value indicating whether to include contents of the <see cref="T:NLog.MappedDiagnosticsContext"/> dictionary.
             </summary>
             <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Layouts.Log4JXmlEventLayout.IncludeNdc">
            <summary>
            Gets or sets whether to include log4j:NDC in output from <see cref="T:NLog.ScopeContext"/> nested context.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Layouts.Log4JXmlEventLayout.IncludeMdlc">
             <summary>
             Obsolete and replaced by <see cref="P:NLog.Layouts.Log4JXmlEventLayout.IncludeScopeProperties"/> with NLog v5.
            
             Gets or sets a value indicating whether to include contents of the <see cref="T:NLog.MappedDiagnosticsLogicalContext"/> dictionary.
             </summary>
             <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Layouts.Log4JXmlEventLayout.IncludeNdlc">
             <summary>
             Obsolete and replaced by <see cref="P:NLog.Layouts.Log4JXmlEventLayout.IncludeNdc"/> with NLog v5.
            
             Gets or sets a value indicating whether to include contents of the <see cref="T:NLog.NestedDiagnosticsLogicalContext"/> stack.
             </summary>
             <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Layouts.Log4JXmlEventLayout.LoggerName">
            <summary>
            Gets or sets the log4j:event logger-xml-attribute. Default: ${logger}
            </summary>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="P:NLog.Layouts.Log4JXmlEventLayout.FormattedMessage">
            <summary>
            Gets or sets the log4j:event message-xml-element. Default: ${message}
            </summary>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="P:NLog.Layouts.Log4JXmlEventLayout.AppInfo">
            <summary>
            Gets or sets the log4j:event log4japp-xml-element. By default it's the friendly name of the current AppDomain.
            </summary>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="P:NLog.Layouts.Log4JXmlEventLayout.WriteThrowableCData">
            <summary>
             Gets or sets whether the log4j:throwable xml-element should be written as CDATA
            </summary>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="P:NLog.Layouts.Log4JXmlEventLayout.IncludeCallSite">
            <summary>
            Gets or sets a value indicating whether to include call site (class and method name) in the information sent over the network.
            </summary>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="P:NLog.Layouts.Log4JXmlEventLayout.IncludeSourceInfo">
            <summary>
            Gets or sets a value indicating whether to include source info (file name and line number) in the information sent over the network.
            </summary>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="M:NLog.Layouts.Log4JXmlEventLayout.GetFormattedMessage(NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Layouts.Log4JXmlEventLayout.RenderFormattedMessage(NLog.LogEventInfo,System.Text.StringBuilder)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.Layouts.SimpleLayout">
            <summary>
            Represents a string with embedded placeholders that can render contextual information.
            </summary>
            <remarks>
            <para>
            This layout is not meant to be used explicitly. Instead you can just use a string containing layout
            renderers everywhere the layout is required.
            </para>
            <a href="https://github.com/NLog/NLog/wiki/SimpleLayout">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/SimpleLayout">Documentation on NLog Wiki</seealso>
        </member>
        <member name="M:NLog.Layouts.SimpleLayout.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Layouts.SimpleLayout" /> class.
            </summary>
        </member>
        <member name="M:NLog.Layouts.SimpleLayout.#ctor(System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Layouts.SimpleLayout" /> class.
            </summary>
            <param name="txt">The layout string to parse.</param>
        </member>
        <member name="M:NLog.Layouts.SimpleLayout.#ctor(System.String,NLog.Config.ConfigurationItemFactory)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Layouts.SimpleLayout"/> class.
            </summary>
            <param name="txt">The layout string to parse.</param>
            <param name="configurationItemFactory">The NLog factories to use when creating references to layout renderers.</param>
        </member>
        <member name="M:NLog.Layouts.SimpleLayout.#ctor(System.String,NLog.Config.ConfigurationItemFactory,System.Nullable{System.Boolean})">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Layouts.SimpleLayout"/> class.
            </summary>
            <param name="txt">The layout string to parse.</param>
            <param name="configurationItemFactory">The NLog factories to use when creating references to layout renderers.</param>
            <param name="throwConfigExceptions">Whether <see cref="T:NLog.NLogConfigurationException"/> should be thrown on parse errors.</param>
        </member>
        <member name="P:NLog.Layouts.SimpleLayout.OriginalText">
            <summary>
            Original text before compile to Layout renderes
            </summary>
        </member>
        <member name="P:NLog.Layouts.SimpleLayout.Text">
            <summary>
            Gets or sets the layout text.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Layouts.SimpleLayout.IsFixedText">
            <summary>
            Is the message fixed? (no Layout renderers used)
            </summary>
        </member>
        <member name="P:NLog.Layouts.SimpleLayout.FixedText">
            <summary>
            Get the fixed text. Only set when <see cref="P:NLog.Layouts.SimpleLayout.IsFixedText"/> is <c>true</c>
            </summary>
        </member>
        <member name="P:NLog.Layouts.SimpleLayout.IsSimpleStringText">
            <summary>
            Is the message a simple formatted string? (Can skip StringBuilder)
            </summary>
        </member>
        <member name="P:NLog.Layouts.SimpleLayout.Renderers">
            <summary>
            Gets a collection of <see cref="T:NLog.LayoutRenderers.LayoutRenderer"/> objects that make up this layout.
            </summary>
        </member>
        <member name="P:NLog.Layouts.SimpleLayout.LayoutRenderers">
            <summary>
            Gets a collection of <see cref="T:NLog.LayoutRenderers.LayoutRenderer"/> objects that make up this layout.
            </summary>
        </member>
        <member name="P:NLog.Layouts.SimpleLayout.StackTraceUsage">
            <summary>
            Gets the level of stack trace information required for rendering.
            </summary>
        </member>
        <member name="M:NLog.Layouts.SimpleLayout.op_Implicit(System.String)~NLog.Layouts.SimpleLayout">
            <summary>
            Converts a text to a simple layout.
            </summary>
            <param name="text">Text to be converted.</param>
            <returns>A <see cref="T:NLog.Layouts.SimpleLayout"/> object.</returns>
        </member>
        <member name="M:NLog.Layouts.SimpleLayout.Escape(System.String)">
            <summary>
            Escapes the passed text so that it can
            be used literally in all places where
            layout is normally expected without being
            treated as layout.
            </summary>
            <param name="text">The text to be escaped.</param>
            <returns>The escaped text.</returns>
            <remarks>
            Escaping is done by replacing all occurrences of
            '${' with '${literal:text=${}'
            </remarks>
        </member>
        <member name="M:NLog.Layouts.SimpleLayout.Evaluate(System.String,NLog.LogEventInfo)">
            <summary>
            Evaluates the specified text by expanding all layout renderers.
            </summary>
            <param name="text">The text to be evaluated.</param>
            <param name="logEvent">Log event to be used for evaluation.</param>
            <returns>The input text with all occurrences of ${} replaced with
            values provided by the appropriate layout renderers.</returns>
        </member>
        <member name="M:NLog.Layouts.SimpleLayout.Evaluate(System.String)">
            <summary>
            Evaluates the specified text by expanding all layout renderers
            in new <see cref="T:NLog.LogEventInfo" /> context.
            </summary>
            <param name="text">The text to be evaluated.</param>
            <returns>The input text with all occurrences of ${} replaced with
            values provided by the appropriate layout renderers.</returns>
        </member>
        <member name="M:NLog.Layouts.SimpleLayout.ToString">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Layouts.SimpleLayout.InitializeLayout">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Layouts.SimpleLayout.Precalculate(NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Layouts.SimpleLayout.TryGetRawValue(NLog.LogEventInfo,System.Object@)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Layouts.SimpleLayout.GetFormattedMessage(NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Layouts.SimpleLayout.RenderFormattedMessage(NLog.LogEventInfo,System.Text.StringBuilder)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.Layouts.Layout`1">
            <summary>
            Typed Layout for easy conversion from NLog Layout logic to a simple value (ex. integer or enum)
            </summary>
            <typeparam name="T"></typeparam>
        </member>
        <member name="P:NLog.Layouts.Layout`1.IsFixed">
            <summary>
            Is fixed value?
            </summary>
        </member>
        <member name="P:NLog.Layouts.Layout`1.FixedValue">
            <summary>
            Fixed value
            </summary>
        </member>
        <member name="M:NLog.Layouts.Layout`1.#ctor(NLog.Layouts.Layout)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Layouts.Layout`1" /> class.
            </summary>
            <param name="layout">Dynamic NLog Layout</param>
        </member>
        <member name="M:NLog.Layouts.Layout`1.#ctor(NLog.Layouts.Layout,System.String,System.Globalization.CultureInfo)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Layouts.Layout`1" /> class.
            </summary>
            <param name="layout">Dynamic NLog Layout</param>
            <param name="parseValueFormat">Format used for parsing string-value into result value type</param>
            <param name="parseValueCulture">Culture used for parsing string-value into result value type</param>
        </member>
        <member name="M:NLog.Layouts.Layout`1.#ctor(`0)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Layouts.Layout`1" /> class.
            </summary>
            <param name="value">Fixed value</param>
        </member>
        <member name="M:NLog.Layouts.Layout`1.RenderTypedValue(NLog.LogEventInfo,`0)">
            <summary>
            Render Value
            </summary>
            <param name="logEvent">Log event for rendering</param>
            <param name="defaultValue">Fallback value when no value available</param>
            <returns>Result value when available, else fallback to defaultValue</returns>
        </member>
        <member name="M:NLog.Layouts.Layout`1.GetFormattedMessage(NLog.LogEventInfo)">
            <summary>
            Renders the value and converts the value into string format
            </summary>
            <remarks>
            Only to implement abstract method from <see cref="T:NLog.Layouts.Layout"/>, and only used when calling <see cref="M:NLog.Layouts.Layout.Render(NLog.LogEventInfo)"/>
            </remarks>
        </member>
        <member name="M:NLog.Layouts.Layout`1.InitializeLayout">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Layouts.Layout`1.CloseLayout">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Layouts.Layout`1.Precalculate(NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Layouts.Layout`1.PrecalculateBuilder(NLog.LogEventInfo,System.Text.StringBuilder)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Layouts.Layout`1.FromMethod(System.Func{NLog.LogEventInfo,`0},NLog.Layouts.LayoutRenderOptions)">
            <summary>
            Create a typed layout from a lambda method.
            </summary>
            <param name="layoutMethod">Method that renders the layout.</param>
            <param name="options">Whether method is ThreadAgnostic and doesn't depend on context of the logging application thread.</param>
            <returns>Instance of typed layout.</returns>
        </member>
        <member name="M:NLog.Layouts.Layout`1.ToString">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Layouts.Layout`1.Equals(System.Object)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Layouts.Layout`1.Equals(`0)">
            <summary>
            Implements Equals using <see cref="P:NLog.Layouts.Layout`1.FixedValue"/>
            </summary>
        </member>
        <member name="M:NLog.Layouts.Layout`1.GetHashCode">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Layouts.Layout`1.op_Implicit(`0)~NLog.Layouts.Layout{`0}">
            <summary>
            Converts a given value to a <see cref="T:NLog.Layouts.Layout`1" />.
            </summary>
            <param name="value">Text to be converted.</param>
        </member>
        <member name="M:NLog.Layouts.Layout`1.op_Implicit(System.String)~NLog.Layouts.Layout{`0}">
            <summary>
            Converts a given text to a <see cref="T:NLog.Layouts.Layout`1" />.
            </summary>
            <param name="layout">Text to be converted.</param>
        </member>
        <member name="M:NLog.Layouts.Layout`1.op_Equality(NLog.Layouts.Layout{`0},`0)">
            <summary>
            Implements the operator == using <see cref="P:NLog.Layouts.Layout`1.FixedValue"/>
            </summary>
        </member>
        <member name="M:NLog.Layouts.Layout`1.op_Inequality(NLog.Layouts.Layout{`0},`0)">
            <summary>
            Implements the operator != using <see cref="P:NLog.Layouts.Layout`1.FixedValue"/>
            </summary>
        </member>
        <member name="T:NLog.Layouts.ValueTypeLayoutInfo">
            <summary>
            Typed Value that is easily configured from NLog.config file
            </summary>
        </member>
        <member name="M:NLog.Layouts.ValueTypeLayoutInfo.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Layouts.ValueTypeLayoutInfo" /> class.
            </summary>
        </member>
        <member name="P:NLog.Layouts.ValueTypeLayoutInfo.Layout">
            <summary>
            Gets or sets the layout that will render the result value
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Layouts.ValueTypeLayoutInfo.ValueType">
            <summary>
            Gets or sets the result value type, for conversion of layout rendering output
            </summary>
            <docgen category='Layout Options' order='50' />
        </member>
        <member name="P:NLog.Layouts.ValueTypeLayoutInfo.DefaultValue">
            <summary>
            Gets or sets the fallback value when result value is not available
            </summary>
            <docgen category='Layout Options' order='50' />
        </member>
        <member name="P:NLog.Layouts.ValueTypeLayoutInfo.ForceDefaultValueNull">
            <summary>
            Gets or sets the fallback value should be null (instead of default value of <see cref="P:NLog.Layouts.ValueTypeLayoutInfo.ValueType"/>) when result value is not available
            </summary>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="P:NLog.Layouts.ValueTypeLayoutInfo.ValueParseFormat">
            <summary>
            Gets or sets format used for parsing parameter string-value for type-conversion
            </summary>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="P:NLog.Layouts.ValueTypeLayoutInfo.ValueParseCulture">
            <summary>
            Gets or sets the culture used for parsing parameter string-value for type-conversion
            </summary>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="M:NLog.Layouts.ValueTypeLayoutInfo.RenderValue(NLog.LogEventInfo)">
            <summary>
            Render Result Value
            </summary>
            <param name="logEvent">Log event for rendering</param>
            <returns>Result value when available, else fallback to defaultValue</returns>
        </member>
        <member name="T:NLog.Layouts.XmlAttribute">
            <summary>
            XML attribute.
            </summary>
        </member>
        <member name="M:NLog.Layouts.XmlAttribute.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Layouts.XmlAttribute" /> class.
            </summary>
        </member>
        <member name="M:NLog.Layouts.XmlAttribute.#ctor(System.String,NLog.Layouts.Layout)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Layouts.XmlAttribute" /> class.
            </summary>
            <param name="name">The name of the attribute.</param>
            <param name="layout">The layout of the attribute's value.</param>
        </member>
        <member name="M:NLog.Layouts.XmlAttribute.#ctor(System.String,NLog.Layouts.Layout,System.Boolean)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Layouts.XmlAttribute" /> class.
            </summary>
            <param name="name">The name of the attribute.</param>
            <param name="layout">The layout of the attribute's value.</param>
            <param name="encode">Encode value with xml-encode</param>
        </member>
        <member name="P:NLog.Layouts.XmlAttribute.Name">
            <summary>
            Gets or sets the name of the attribute.
            </summary>
            <docgen category='Layout Options' order='1' />
        </member>
        <member name="P:NLog.Layouts.XmlAttribute.Layout">
            <summary>
            Gets or sets the layout that will be rendered as the attribute's value.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Layouts.XmlAttribute.ValueType">
            <summary>
            Gets or sets the result value type, for conversion of layout rendering output
            </summary>
            <docgen category='Layout Options' order='50' />
        </member>
        <member name="P:NLog.Layouts.XmlAttribute.DefaultValue">
            <summary>
            Gets or sets the fallback value when result value is not available
            </summary>
            <docgen category='Layout Options' order='50' />
        </member>
        <member name="P:NLog.Layouts.XmlAttribute.Encode">
            <summary>
            Gets or sets whether output should be encoded with Xml-string escaping, or be treated as valid xml-attribute-value
            </summary>
            <docgen category='Layout Options' order='50' />
        </member>
        <member name="P:NLog.Layouts.XmlAttribute.IncludeEmptyValue">
            <summary>
            Gets or sets whether an attribute with empty value should be included in the output
            </summary>
            <docgen category='Layout Options' order='50' />
        </member>
        <member name="T:NLog.Layouts.XmlElement">
            <summary>
            A XML Element
            </summary>
        </member>
        <member name="M:NLog.Layouts.XmlElement.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Layouts.XmlElement"/> class.
            </summary>
        </member>
        <member name="M:NLog.Layouts.XmlElement.#ctor(System.String,NLog.Layouts.Layout)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Layouts.XmlElement"/> class.
            </summary>
        </member>
        <member name="P:NLog.Layouts.XmlElement.Name">
            <summary>
            Name of the element
            </summary>
            <remarks>
            Default value "item"
            </remarks>
            <docgen category='Layout Options' order='1' />
        </member>
        <member name="P:NLog.Layouts.XmlElement.Value">
            <summary>
            Value inside the element
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Layouts.XmlElement.Layout">
            <summary>
            Value inside the element
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Layouts.XmlElement.Encode">
            <summary>
            Gets or sets whether output should be encoded with Xml-string escaping, or be treated as valid xml-element-value
            </summary>
            <docgen category='Layout Options' order='50' />
        </member>
        <member name="T:NLog.Layouts.XmlElementBase">
            <summary>
            A specialized layout that renders XML-formatted events.
            </summary>
        </member>
        <member name="M:NLog.Layouts.XmlElementBase.#ctor(System.String,NLog.Layouts.Layout)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Layouts.XmlElementBase"/> class.
            </summary>
            <param name="elementName">The name of the top XML node</param>
            <param name="elementValue">The value of the top XML node</param>
        </member>
        <member name="P:NLog.Layouts.XmlElementBase.ElementNameInternal">
            <summary>
            Name of the XML element
            </summary>
            <remarks>Upgrade to private protected when using C# 7.2 </remarks>
        </member>
        <member name="F:NLog.Layouts.XmlElementBase.LayoutWrapper">
            <summary>
            Value inside the XML element
            </summary>
            <remarks>Upgrade to private protected when using C# 7.2 </remarks>
        </member>
        <member name="P:NLog.Layouts.XmlElementBase.IndentXml">
            <summary>
            Auto indent and create new lines
            </summary>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="P:NLog.Layouts.XmlElementBase.Elements">
            <summary>
            Gets the array of xml 'elements' configurations.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Layouts.XmlElementBase.Attributes">
            <summary>
            Gets the array of 'attributes' configurations for the element
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Layouts.XmlElementBase.IncludeEmptyValue">
            <summary>
            Gets or sets whether a ElementValue with empty value should be included in the output
            </summary>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="P:NLog.Layouts.XmlElementBase.IncludeEventProperties">
            <summary>
            Gets or sets the option to include all properties from the log event (as XML)
            </summary>
            <docgen category='Layout Output' order='10' />
        </member>
        <member name="P:NLog.Layouts.XmlElementBase.IncludeScopeProperties">
            <summary>
            Gets or sets whether to include the contents of the <see cref="T:NLog.ScopeContext"/> dictionary.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Layouts.XmlElementBase.IncludeMdc">
             <summary>
             Obsolete and replaced by <see cref="P:NLog.Layouts.XmlElementBase.IncludeScopeProperties"/> with NLog v5.
            
             Gets or sets a value indicating whether to include contents of the <see cref="T:NLog.MappedDiagnosticsContext"/> dictionary.
             </summary>
             <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Layouts.XmlElementBase.IncludeMdlc">
             <summary>
             Obsolete and replaced by <see cref="P:NLog.Layouts.XmlElementBase.IncludeScopeProperties"/> with NLog v5.
            
             Gets or sets a value indicating whether to include contents of the <see cref="T:NLog.MappedDiagnosticsLogicalContext"/> dictionary.
             </summary>
             <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Layouts.XmlElementBase.IncludeAllProperties">
             <summary>
             Obsolete and replaced by <see cref="P:NLog.Layouts.XmlElementBase.IncludeEventProperties"/> with NLog v5.
            
             Gets or sets the option to include all properties from the log event (as XML)
             </summary>
             <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Layouts.XmlElementBase.ExcludeProperties">
            <summary>
            List of property names to exclude when <see cref="P:NLog.Layouts.XmlElementBase.IncludeAllProperties"/> is true
            </summary>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="P:NLog.Layouts.XmlElementBase.PropertiesElementName">
             <summary>
             XML element name to use when rendering properties
             </summary>
             <remarks>
             Support string-format where {0} means property-key-name
            
             Skips closing element tag when having configured <see cref="P:NLog.Layouts.XmlElementBase.PropertiesElementValueAttribute"/>
             </remarks>
             <docgen category='Layout Options' order='100' />
        </member>
        <member name="P:NLog.Layouts.XmlElementBase.PropertiesElementKeyAttribute">
             <summary>
             XML attribute name to use when rendering property-key
            
             When null (or empty) then key-attribute is not included
             </summary>
             <remarks>
             Will replace newlines in attribute-value with &#13;&#10;
             </remarks>
             <docgen category='Layout Options' order='100' />
        </member>
        <member name="P:NLog.Layouts.XmlElementBase.PropertiesElementValueAttribute">
             <summary>
             XML attribute name to use when rendering property-value
            
             When null (or empty) then value-attribute is not included and
             value is formatted as XML-element-value
             </summary>
             <remarks>
             Skips closing element tag when using attribute for value
            
             Will replace newlines in attribute-value with &#13;&#10;
             </remarks>
             <docgen category='Layout Options' order='100' />
        </member>
        <member name="P:NLog.Layouts.XmlElementBase.PropertiesCollectionItemName">
            <summary>
            XML element name to use for rendering IList-collections items
            </summary>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="P:NLog.Layouts.XmlElementBase.MaxRecursionLimit">
            <summary>
            How far should the XML serializer follow object references before backing off
            </summary>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="M:NLog.Layouts.XmlElementBase.InitializeLayout">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Layouts.XmlElementBase.CloseLayout">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Layouts.XmlElementBase.RenderFormattedMessage(NLog.LogEventInfo,System.Text.StringBuilder)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Layouts.XmlElementBase.GetFormattedMessage(NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Layouts.XmlElementBase.RenderAttribute(System.Text.StringBuilder,System.String,System.String)">
            <summary>
            write attribute, only if <paramref name="attributeName"/> is not empty
            </summary>
            <param name="sb"></param>
            <param name="attributeName"></param>
            <param name="value"></param>
            <returns>rendered</returns>
        </member>
        <member name="M:NLog.Layouts.XmlElementBase.ToString">
            <inheritdoc/>
        </member>
        <member name="T:NLog.Layouts.XmlLayout">
            <summary>
            A specialized layout that renders XML-formatted events.
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/XmlLayout">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/XmlLayout">Documentation on NLog Wiki</seealso>
        </member>
        <member name="M:NLog.Layouts.XmlLayout.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Layouts.XmlLayout"/> class.
            </summary>
        </member>
        <member name="M:NLog.Layouts.XmlLayout.#ctor(System.String,NLog.Layouts.Layout)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Layouts.XmlLayout"/> class.
            </summary>
            <param name="elementName">The name of the top XML node</param>
            <param name="elementValue">The value of the top XML node</param>
        </member>
        <member name="P:NLog.Layouts.XmlLayout.ElementName">
            <summary>
            Name of the root XML element
            </summary>
            <remarks>
            Default value "logevent"
            </remarks>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Layouts.XmlLayout.ElementValue">
            <summary>
            Value inside the root XML element
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Layouts.XmlLayout.ElementEncode">
            <summary>
            Determines whether or not this attribute will be Xml encoded.
            </summary>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="T:NLog.LayoutTypedExtensions">
            <summary>
            Extensions for NLog <see cref="T:NLog.Layouts.Layout`1"/>.
            </summary>
        </member>
        <member name="M:NLog.LayoutTypedExtensions.RenderValue``1(NLog.Layouts.Layout{``0},NLog.LogEventInfo,``0)">
            <summary>
            Renders the logevent into a result-value by using the provided layout
            </summary>
            <remarks>Inside a <see cref="T:NLog.Targets.Target"/>, <see cref="M:NLog.Targets.Target.RenderLogEvent(NLog.Layouts.Layout,NLog.LogEventInfo)"/> is preferred for performance reasons.</remarks>
            <typeparam name="T"></typeparam>
            <param name="layout">The layout.</param>
            <param name="logEvent">The logevent info.</param>
            <param name="defaultValue">Fallback value when no value available</param>
            <returns>Result value when available, else fallback to defaultValue</returns>
        </member>
        <member name="T:NLog.LogEventBuilder">
            <summary>
            A fluent builder for logging events to NLog.
            </summary>
        </member>
        <member name="M:NLog.LogEventBuilder.#ctor(NLog.ILogger)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.LogEventBuilder"/> class.
            </summary>
            <param name="logger">The <see cref="T:NLog.Logger"/> to send the log event.</param>
        </member>
        <member name="M:NLog.LogEventBuilder.#ctor(NLog.ILogger,NLog.LogLevel)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.LogEventBuilder"/> class.
            </summary>
            <param name="logger">The <see cref="T:NLog.Logger"/> to send the log event.</param>
            <param name="logLevel">The log level. LogEvent is only created when <see cref="T:NLog.LogLevel"/> is enabled for <paramref name="logger"/></param>
        </member>
        <member name="P:NLog.LogEventBuilder.Logger">
            <summary>
            The logger to write the log event to
            </summary>
        </member>
        <member name="P:NLog.LogEventBuilder.LogEvent">
            <summary>
            Logging event that will be written
            </summary>
        </member>
        <member name="M:NLog.LogEventBuilder.Property``1(System.String,``0)">
            <summary>
            Sets a per-event context property on the logging event.
            </summary>
            <param name="propertyName">The name of the context property.</param>
            <param name="propertyValue">The value of the context property.</param>
        </member>
        <member name="M:NLog.LogEventBuilder.Properties(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{System.String,System.Object}})">
            <summary>
            Sets multiple per-event context properties on the logging event.
            </summary>
            <param name="properties">The properties to set.</param>
        </member>
        <member name="M:NLog.LogEventBuilder.Exception(System.Exception)">
            <summary>
            Sets the <paramref name="exception"/> information of the logging event.
            </summary>
            <param name="exception">The exception information of the logging event.</param>
        </member>
        <member name="M:NLog.LogEventBuilder.TimeStamp(System.DateTime)">
            <summary>
            Sets the timestamp of the logging event.
            </summary>
            <param name="timeStamp">The timestamp of the logging event.</param>
        </member>
        <member name="M:NLog.LogEventBuilder.Message(System.String)">
            <summary>
            Sets the log message on the logging event.
            </summary>
            <param name="message">A <see langword="string" /> to be written.</param>
        </member>
        <member name="M:NLog.LogEventBuilder.Message``1(System.String,``0)">
            <summary>
            Sets the log message and parameters for formatting for the logging event.
            </summary>
            <typeparam name="TArgument">The type of the argument.</typeparam>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.LogEventBuilder.Message``2(System.String,``0,``1)">
            <summary>
            Sets the log message and parameters for formatting on the logging event.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
        </member>
        <member name="M:NLog.LogEventBuilder.Message``3(System.String,``0,``1,``2)">
            <summary>
            Sets the log message and parameters for formatting on the logging event.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <typeparam name="TArgument3">The type of the third argument.</typeparam>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
            <param name="argument3">The third argument to format.</param>
        </member>
        <member name="M:NLog.LogEventBuilder.Message(System.String,System.Object[])">
            <summary>
            Sets the log message and parameters for formatting on the logging event.
            </summary>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.LogEventBuilder.Message(System.IFormatProvider,System.String,System.Object[])">
            <summary>
            Sets the log message and parameters for formatting on the logging event.
            </summary>
            <param name="formatProvider">An object that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.LogEventBuilder.Callsite(System.String,System.String,System.String,System.Int32)">
            <summary>
            Writes the log event to the underlying logger.
            </summary>
            <param name="callerClassName">The class of the caller to the method. This is captured by the NLog engine when necessary</param>
            <param name="callerMemberName">The method or property name of the caller to the method. This is set at by the compiler.</param>
            <param name="callerFilePath">The full path of the source file that contains the caller. This is set at by the compiler.</param>
            <param name="callerLineNumber">The line number in the source file at which the method is called. This is set at by the compiler.</param>
        </member>
        <member name="M:NLog.LogEventBuilder.Log(NLog.LogLevel,System.String,System.String,System.Int32)">
            <summary>
            Writes the log event to the underlying logger.
            </summary>
            <param name="logLevel">The log level. Optional but when assigned to <see cref="F:NLog.LogLevel.Off"/> then it will discard the LogEvent.</param>
            <param name="callerMemberName">The method or property name of the caller to the method. This is set at by the compiler.</param>
            <param name="callerFilePath">The full path of the source file that contains the caller. This is set at by the compiler.</param>
            <param name="callerLineNumber">The line number in the source file at which the method is called. This is set at by the compiler.</param>
        </member>
        <member name="M:NLog.LogEventBuilder.Log(System.Type)">
            <summary>
            Writes the log event to the underlying logger.
            </summary>
            <param name="wrapperType">Type of custom Logger wrapper.</param>
        </member>
        <member name="T:NLog.LogEventInfo">
            <summary>
            Represents the logging event.
            </summary>
        </member>
        <member name="F:NLog.LogEventInfo.ZeroDate">
            <summary>
            Gets the date of the first log event created.
            </summary>
        </member>
        <member name="F:NLog.LogEventInfo._formattedMessage">
            <summary>
            The formatted log message.
            </summary>
        </member>
        <member name="F:NLog.LogEventInfo._message">
            <summary>
            The log message including any parameter placeholders
            </summary>
        </member>
        <member name="M:NLog.LogEventInfo.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.LogEventInfo" /> class.
            </summary>
        </member>
        <member name="M:NLog.LogEventInfo.#ctor(NLog.LogLevel,System.String,System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.LogEventInfo" /> class.
            </summary>
            <param name="level">Log level.</param>
            <param name="loggerName">Override default Logger name. Default <see cref="P:NLog.Logger.Name"/> is used when <c>null</c></param>
            <param name="message">Log message including parameter placeholders.</param>
        </member>
        <member name="M:NLog.LogEventInfo.#ctor(NLog.LogLevel,System.String,System.String,System.Collections.Generic.IList{NLog.MessageTemplates.MessageTemplateParameter})">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.LogEventInfo" /> class.
            </summary>
            <param name="level">Log level.</param>
            <param name="loggerName">Override default Logger name. Default <see cref="P:NLog.Logger.Name"/> is used when <c>null</c></param>
            <param name="message">Log message including parameter placeholders.</param>
            <param name="messageTemplateParameters">Already parsed message template parameters.</param>
        </member>
        <member name="M:NLog.LogEventInfo.#ctor(NLog.LogLevel,System.String,System.String,System.String,System.Collections.Generic.IList{NLog.MessageTemplates.MessageTemplateParameter})">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.LogEventInfo" /> class.
            </summary>
            <param name="level">Log level.</param>
            <param name="loggerName">Override default Logger name. Default <see cref="P:NLog.Logger.Name"/> is used when <c>null</c></param>
            <param name="formattedMessage">Pre-formatted log message for ${message}.</param>
            <param name="messageTemplate">Log message-template including parameter placeholders for ${message:raw=true}.</param>
            <param name="messageTemplateParameters">Already parsed message template parameters.</param>
        </member>
        <member name="M:NLog.LogEventInfo.#ctor(NLog.LogLevel,System.String,System.String,System.Collections.Generic.IReadOnlyList{System.Collections.Generic.KeyValuePair{System.Object,System.Object}})">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.LogEventInfo" /> class.
            </summary>
            <param name="level">Log level.</param>
            <param name="loggerName">Override default Logger name. Default <see cref="P:NLog.Logger.Name"/> is used when <c>null</c></param>
            <param name="message">Log message.</param>
            <param name="eventProperties">List of event-properties</param>
        </member>
        <member name="M:NLog.LogEventInfo.#ctor(NLog.LogLevel,System.String,System.IFormatProvider,System.String,System.Object[])">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.LogEventInfo" /> class.
            </summary>
            <param name="level">Log level.</param>
            <param name="loggerName">Override default Logger name. Default <see cref="P:NLog.Logger.Name"/> is used when <c>null</c></param>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">Log message including parameter placeholders.</param>
            <param name="parameters">Parameter array.</param>
        </member>
        <member name="M:NLog.LogEventInfo.#ctor(NLog.LogLevel,System.String,System.IFormatProvider,System.String,System.Object[],System.Exception)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.LogEventInfo" /> class.
            </summary>
            <param name="level">Log level.</param>
            <param name="loggerName">Override default Logger name. Default <see cref="P:NLog.Logger.Name"/> is used when <c>null</c></param>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">Log message including parameter placeholders.</param>
            <param name="parameters">Parameter array.</param>
            <param name="exception">Exception information.</param>
        </member>
        <member name="P:NLog.LogEventInfo.SequenceID">
            <summary>
            Gets the unique identifier of log event which is automatically generated
            and monotonously increasing.
            </summary>
        </member>
        <member name="P:NLog.LogEventInfo.TimeStamp">
            <summary>
            Gets or sets the timestamp of the logging event.
            </summary>
        </member>
        <member name="P:NLog.LogEventInfo.Level">
            <summary>
            Gets or sets the level of the logging event.
            </summary>
        </member>
        <member name="P:NLog.LogEventInfo.HasStackTrace">
            <summary>
            Gets a value indicating whether stack trace has been set for this event.
            </summary>
        </member>
        <member name="P:NLog.LogEventInfo.UserStackFrame">
             <summary>
             Obsolete and replaced by <see cref="P:NLog.LogEventInfo.CallerMemberName"/> or ${callsite} with NLog v5.3.
            
             Gets the stack frame of the method that did the logging.
             </summary>
        </member>
        <member name="P:NLog.LogEventInfo.UserStackFrameNumber">
            <summary>
            Gets the number index of the stack frame that represents the user
            code (not the NLog code).
            </summary>
        </member>
        <member name="P:NLog.LogEventInfo.StackTrace">
            <summary>
            Gets the entire stack trace.
            </summary>
        </member>
        <member name="P:NLog.LogEventInfo.CallerClassName">
            <summary>
            Gets the callsite class name
            </summary>
        </member>
        <member name="P:NLog.LogEventInfo.CallerMemberName">
            <summary>
            Gets the callsite member function name
            </summary>
        </member>
        <member name="P:NLog.LogEventInfo.CallerFilePath">
            <summary>
            Gets the callsite source file path
            </summary>
        </member>
        <member name="P:NLog.LogEventInfo.CallerLineNumber">
            <summary>
            Gets the callsite source file line number
            </summary>
        </member>
        <member name="P:NLog.LogEventInfo.Exception">
            <summary>
            Gets or sets the exception information.
            </summary>
        </member>
        <member name="P:NLog.LogEventInfo.LoggerName">
            <summary>
            Gets or sets the logger name.
            </summary>
        </member>
        <member name="P:NLog.LogEventInfo.Message">
            <summary>
            Gets or sets the log message including any parameter placeholders.
            </summary>
        </member>
        <member name="P:NLog.LogEventInfo.Parameters">
            <summary>
            Gets or sets the parameter values or null if no parameters have been specified.
            </summary>
        </member>
        <member name="P:NLog.LogEventInfo.FormatProvider">
            <summary>
            Gets or sets the format provider that was provided while logging or <see langword="null" />
            when no formatProvider was specified.
            </summary>
        </member>
        <member name="P:NLog.LogEventInfo.MessageFormatter">
            <summary>
            Gets or sets the message formatter for generating <see cref="P:NLog.LogEventInfo.FormattedMessage"/>
            Uses string.Format(...) when nothing else has been configured.
            </summary>
        </member>
        <member name="P:NLog.LogEventInfo.FormattedMessage">
            <summary>
            Gets the formatted message.
            </summary>
        </member>
        <member name="P:NLog.LogEventInfo.HasProperties">
            <summary>
            Checks if any per-event properties (Without allocation)
            </summary>
        </member>
        <member name="P:NLog.LogEventInfo.Properties">
            <summary>
            Gets the dictionary of per-event context properties.
            </summary>
        </member>
        <member name="M:NLog.LogEventInfo.CreateOrUpdatePropertiesInternal(System.Boolean,System.Collections.Generic.IList{NLog.MessageTemplates.MessageTemplateParameter})">
            <summary>
            Gets the dictionary of per-event context properties.
            Internal helper for the PropertiesDictionary type.
            </summary>
            <param name="forceCreate">Create the event-properties dictionary, even if no initial template parameters</param>
            <param name="templateParameters">Provided when having parsed the message template and capture template parameters (else null)</param>
            <returns></returns>
        </member>
        <member name="P:NLog.LogEventInfo.MessageTemplateParameters">
            <summary>
            Gets the named parameters extracted from parsing <see cref="P:NLog.LogEventInfo.Message"/> as MessageTemplate
            </summary>
        </member>
        <member name="M:NLog.LogEventInfo.CreateNullEvent">
            <summary>
            Creates the null event.
            </summary>
            <returns>Null log event.</returns>
        </member>
        <member name="M:NLog.LogEventInfo.Create(NLog.LogLevel,System.String,System.String)">
            <summary>
            Creates the log event.
            </summary>
            <param name="logLevel">The log level.</param>
            <param name="loggerName">Override default Logger name. Default <see cref="P:NLog.Logger.Name"/> is used when <c>null</c></param>
            <param name="message">The message.</param>
            <returns>Instance of <see cref="T:NLog.LogEventInfo"/>.</returns>
        </member>
        <member name="M:NLog.LogEventInfo.Create(NLog.LogLevel,System.String,System.IFormatProvider,System.String,System.Object[])">
            <summary>
            Creates the log event.
            </summary>
            <param name="logLevel">The log level.</param>
            <param name="loggerName">Override default Logger name. Default <see cref="P:NLog.Logger.Name"/> is used when <c>null</c></param>
            <param name="formatProvider">The format provider.</param>
            <param name="message">The message.</param>
            <param name="parameters">The parameters.</param>
            <returns>Instance of <see cref="T:NLog.LogEventInfo"/>.</returns>
        </member>
        <member name="M:NLog.LogEventInfo.Create(NLog.LogLevel,System.String,System.IFormatProvider,System.Object)">
            <summary>
            Creates the log event.
            </summary>
            <param name="logLevel">The log level.</param>
            <param name="loggerName">Override default Logger name. Default <see cref="P:NLog.Logger.Name"/> is used when <c>null</c></param>
            <param name="formatProvider">The format provider.</param>
            <param name="message">The message.</param>
            <returns>Instance of <see cref="T:NLog.LogEventInfo"/>.</returns>
        </member>
        <member name="M:NLog.LogEventInfo.Create(NLog.LogLevel,System.String,System.Exception,System.IFormatProvider,System.String)">
            <summary>
            Creates the log event.
            </summary>
            <param name="logLevel">The log level.</param>
            <param name="loggerName">Override default Logger name. Default <see cref="P:NLog.Logger.Name"/> is used when <c>null</c></param>
            <param name="exception">The exception.</param>
            <param name="formatProvider">The format provider.</param>
            <param name="message">The message.</param>
            <returns>Instance of <see cref="T:NLog.LogEventInfo"/>.</returns>
        </member>
        <member name="M:NLog.LogEventInfo.Create(NLog.LogLevel,System.String,System.Exception,System.IFormatProvider,System.String,System.Object[])">
            <summary>
            Creates the log event.
            </summary>
            <param name="logLevel">The log level.</param>
            <param name="loggerName">Override default Logger name. Default <see cref="P:NLog.Logger.Name"/> is used when <c>null</c></param>
            <param name="exception">The exception.</param>
            <param name="formatProvider">The format provider.</param>
            <param name="message">The message.</param>
            <param name="parameters">The parameters.</param>
            <returns>Instance of <see cref="T:NLog.LogEventInfo"/>.</returns>
        </member>
        <member name="M:NLog.LogEventInfo.WithContinuation(NLog.Common.AsyncContinuation)">
            <summary>
            Creates <see cref="T:NLog.Common.AsyncLogEventInfo"/> from this <see cref="T:NLog.LogEventInfo"/> by attaching the specified asynchronous continuation.
            </summary>
            <param name="asyncContinuation">The asynchronous continuation.</param>
            <returns>Instance of <see cref="T:NLog.Common.AsyncLogEventInfo"/> with attached continuation.</returns>
        </member>
        <member name="M:NLog.LogEventInfo.ToString">
            <summary>
            Returns a string representation of this log event.
            </summary>
            <returns>String representation of the log event.</returns>
        </member>
        <member name="M:NLog.LogEventInfo.SetStackTrace(System.Diagnostics.StackTrace)">
            <summary>
            Sets the stack trace for the event info.
            </summary>
            <param name="stackTrace">The stack trace.</param>
        </member>
        <member name="M:NLog.LogEventInfo.SetStackTrace(System.Diagnostics.StackTrace,System.Int32)">
            <summary>
            Sets the stack trace for the event info.
            </summary>
            <param name="stackTrace">The stack trace.</param>
            <param name="userStackFrame">Index of the first user stack frame within the stack trace (Negative means NLog should skip stackframes from System-assemblies).</param>
        </member>
        <member name="M:NLog.LogEventInfo.SetCallerInfo(System.String,System.String,System.String,System.Int32)">
            <summary>
            Sets the details retrieved from the Caller Information Attributes
            </summary>
            <param name="callerClassName"></param>
            <param name="callerMemberName"></param>
            <param name="callerFilePath"></param>
            <param name="callerLineNumber"></param>
        </member>
        <member name="T:NLog.LogFactory`1">
            <summary>
            Specialized LogFactory that can return instances of custom logger types.
            </summary>
            <remarks>Use this only when a custom Logger type is defined.</remarks>
            <typeparam name="T">The type of the logger to be returned. Must inherit from <see cref="T:NLog.Logger"/>.</typeparam>
        </member>
        <member name="M:NLog.LogFactory`1.GetLogger(System.String)">
            <summary>
            Gets the logger with type <typeparamref name="T"/>.
            </summary>
            <param name="name">The logger name.</param>
            <returns>An instance of <typeparamref name="T"/>.</returns>
        </member>
        <member name="M:NLog.LogFactory`1.GetCurrentClassLogger">
            <summary>
            Gets a custom logger with the full name of the current class (so namespace and class name) and type <typeparamref name="T"/>.
            </summary>
            <returns>An instance of <typeparamref name="T"/>.</returns>
            <remarks>This is a slow-running method.
            Make sure you're not doing this in a loop.</remarks>
        </member>
        <member name="T:NLog.LogFactory">
            <summary>
            Creates and manages instances of <see cref="T:NLog.Logger" /> objects.
            </summary>
        </member>
        <member name="F:NLog.LogFactory._syncRoot">
            <remarks>
            Internal for unit tests
            </remarks>
        </member>
        <member name="F:NLog.LogFactory._candidateConfigFilePaths">
            <summary>
            Overwrite possible file paths (including filename) for possible NLog config files.
            When this property is <c>null</c>, the default file paths (<see cref="M:NLog.LogFactory.GetCandidateConfigFilePaths"/> are used.
            </summary>
        </member>
        <member name="E:NLog.LogFactory.ConfigurationChanged">
            <summary>
            Occurs when logging <see cref="P:NLog.LogFactory.Configuration" /> changes. Both when assigned to new config or config unloaded.
            </summary>
            <remarks>
            Note <see cref="P:NLog.Config.LoggingConfigurationChangedEventArgs.ActivatedConfiguration"/> can be <c>null</c> when unloading configuration at shutdown.
            </remarks>
        </member>
        <member name="E:NLog.LogFactory.ConfigurationReloaded">
            <summary>
            Obsolete and replaced by <see cref="E:NLog.LogFactory.ConfigurationChanged"/> with NLog v5.2.
            Occurs when logging <see cref="P:NLog.LogFactory.Configuration" /> gets reloaded.
            </summary>
        </member>
        <member name="M:NLog.LogFactory.#cctor">
            <summary>
            Initializes static members of the LogManager class.
            </summary>
        </member>
        <member name="M:NLog.LogFactory.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.LogFactory" /> class.
            </summary>
        </member>
        <member name="M:NLog.LogFactory.#ctor(NLog.Config.LoggingConfiguration)">
             <summary>
             Obsolete instead use <see cref="T:NLog.LogFactory"/> default-constructor, and assign <see cref="P:NLog.LogFactory.Configuration"/> with NLog 5.0.
            
             Initializes a new instance of the <see cref="T:NLog.LogFactory" /> class.
             </summary>
             <param name="config">The config.</param>
        </member>
        <member name="M:NLog.LogFactory.#ctor(NLog.Config.ILoggingConfigurationLoader,NLog.Internal.Fakeables.IAppEnvironment)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.LogFactory" /> class.
            </summary>
            <param name="configLoader">The config loader</param>
            <param name="appEnvironment">The custom AppEnvironmnet override</param>
        </member>
        <member name="P:NLog.LogFactory.CurrentAppDomain">
            <summary>
            Gets the current <see cref="T:NLog.Internal.Fakeables.IAppDomain"/>.
            </summary>
        </member>
        <member name="P:NLog.LogFactory.ThrowExceptions">
            <summary>
            Gets or sets a value indicating whether exceptions should be thrown. See also <see cref="P:NLog.LogFactory.ThrowConfigExceptions"/>.
            </summary>
            <value>A value of <c>true</c> if exception should be thrown; otherwise, <c>false</c>.</value>
            <remarks>By default exceptions are not thrown under any circumstances.</remarks>
        </member>
        <member name="P:NLog.LogFactory.ThrowConfigExceptions">
             <summary>
             Gets or sets a value indicating whether <see cref="T:NLog.NLogConfigurationException"/> should be thrown.
            
             If <c>null</c> then <see cref="P:NLog.LogFactory.ThrowExceptions"/> is used.
             </summary>
             <value>A value of <c>true</c> if exception should be thrown; otherwise, <c>false</c>.</value>
             <remarks>
             This option is for backwards-compatibility.
             By default exceptions are not thrown under any circumstances.
             </remarks>
        </member>
        <member name="P:NLog.LogFactory.KeepVariablesOnReload">
            <summary>
            Gets or sets a value indicating whether Variables should be kept on configuration reload.
            </summary>
        </member>
        <member name="P:NLog.LogFactory.AutoShutdown">
            <summary>
            Gets or sets a value indicating whether to automatically call <see cref="M:NLog.LogFactory.Shutdown"/>
            on AppDomain.Unload or AppDomain.ProcessExit
            </summary>
        </member>
        <member name="P:NLog.LogFactory.Configuration">
            <summary>
            Gets or sets the current logging configuration.
            </summary>
            <remarks>
            Setter will re-configure all <see cref="T:NLog.Logger"/>-objects, so no need to also call <see cref="M:NLog.LogFactory.ReconfigExistingLoggers" />
            </remarks>
        </member>
        <member name="P:NLog.LogFactory.ServiceRepository">
            <summary>
            Repository of interfaces used by NLog to allow override for dependency injection
            </summary>
        </member>
        <member name="P:NLog.LogFactory.GlobalThreshold">
            <summary>
            Gets or sets the global log level threshold. Log events below this threshold are not logged.
            </summary>
        </member>
        <member name="P:NLog.LogFactory.DefaultCultureInfo">
            <summary>
            Gets or sets the default culture info to use as <see cref="P:NLog.LogEventInfo.FormatProvider"/>.
            </summary>
            <value>
            Specific culture info or null to use <see cref="P:System.Globalization.CultureInfo.CurrentCulture"/>
            </value>
        </member>
        <member name="M:NLog.LogFactory.Dispose">
            <summary>
            Performs application-defined tasks associated with freeing, releasing, or resetting
            unmanaged resources.
            </summary>
        </member>
        <member name="M:NLog.LogFactory.Setup">
            <summary>
            Begins configuration of the LogFactory options using fluent interface
            </summary>
        </member>
        <member name="M:NLog.LogFactory.Setup(System.Action{NLog.Config.ISetupBuilder})">
            <summary>
            Begins configuration of the LogFactory options using fluent interface
            </summary>
        </member>
        <member name="M:NLog.LogFactory.CreateNullLogger">
            <summary>
            Creates a logger that discards all log messages.
            </summary>
            <returns>Null logger instance.</returns>
        </member>
        <member name="M:NLog.LogFactory.GetCurrentClassLogger">
            <summary>
            Gets the logger with the full name of the current class, so namespace and class name.
            </summary>
            <returns>The logger.</returns>
            <remarks>This method introduces performance hit, because of StackTrace capture.
            Make sure you are not calling this method in a loop.</remarks>
        </member>
        <member name="M:NLog.LogFactory.GetCurrentClassLogger``1">
            <summary>
            Gets the logger with the full name of the current class, so namespace and class name.
            Use <typeparamref name="T"/>  to create instance of a custom <see cref="T:NLog.Logger"/>.
            If you haven't defined your own <see cref="T:NLog.Logger"/> class, then use the overload without the type parameter.
            </summary>
            <returns>The logger with type <typeparamref name="T"/>.</returns>
            <typeparam name="T">Type of the logger</typeparam>
            <remarks>This method introduces performance hit, because of StackTrace capture.
            Make sure you are not calling this method in a loop.</remarks>
        </member>
        <member name="M:NLog.LogFactory.GetCurrentClassLogger(System.Type)">
            <summary>
            Obsolete and replaced by <see cref="M:NLog.LogFactory.GetCurrentClassLogger``1"/> with NLog v5.2.
            Gets a custom logger with the full name of the current class, so namespace and class name.
            Use <paramref name="loggerType"/> to create instance of a custom <see cref="T:NLog.Logger"/>.
            If you haven't defined your own <see cref="T:NLog.Logger"/> class, then use the overload without the loggerType.
            </summary>
            <param name="loggerType">The type of the logger to create. The type must inherit from <see cref="T:NLog.Logger"/></param>
            <returns>The logger of type <paramref name="loggerType"/>.</returns>
            <remarks>This method introduces performance hit, because of StackTrace capture.
            Make sure you are not calling this method in a loop.</remarks>
        </member>
        <member name="M:NLog.LogFactory.GetLogger(System.String)">
            <summary>
            Gets the specified named logger.
            </summary>
            <param name="name">Name of the logger.</param>
            <returns>The logger reference. Multiple calls to <c>GetLogger</c> with the same argument
            are not guaranteed to return the same logger reference.</returns>
        </member>
        <member name="M:NLog.LogFactory.GetLogger``1(System.String)">
            <summary>
            Gets the specified named logger.
            Use <typeparamref name="T"/>  to create instance of a custom <see cref="T:NLog.Logger"/>.
            If you haven't defined your own <see cref="T:NLog.Logger"/> class, then use the overload without the type parameter.
            </summary>
            <param name="name">Name of the logger.</param>
            <typeparam name="T">Type of the logger</typeparam>
            <returns>The logger reference with type <typeparamref name="T"/>. Multiple calls to <c>GetLogger</c> with the same argument
            are not guaranteed to return the same logger reference.</returns>
        </member>
        <member name="M:NLog.LogFactory.GetLogger(System.String,System.Type)">
            <summary>
            Obsolete and replaced by <see cref="M:NLog.LogFactory.GetLogger``1(System.String)"/> with NLog v5.2.
            Gets the specified named logger.
            Use <paramref name="loggerType"/> to create instance of a custom <see cref="T:NLog.Logger"/>.
            If you haven't defined your own <see cref="T:NLog.Logger"/> class, then use the overload without the loggerType.
            </summary>
            <param name="name">Name of the logger.</param>
            <param name="loggerType">The type of the logger to create. The type must inherit from <see cref="T:NLog.Logger" />.</param>
            <returns>The logger of type <paramref name="loggerType"/>. Multiple calls to <c>GetLogger</c> with the
            same argument aren't guaranteed to return the same logger reference.</returns>
        </member>
        <member name="M:NLog.LogFactory.ReconfigExistingLoggers">
            <summary>
            Loops through all loggers previously returned by GetLogger and recalculates their
            target and filter list. Useful after modifying the configuration programmatically
            to ensure that all loggers have been properly configured.
            </summary>
        </member>
        <member name="M:NLog.LogFactory.ReconfigExistingLoggers(System.Boolean)">
            <summary>
            Loops through all loggers previously returned by GetLogger and recalculates their
            target and filter list. Useful after modifying the configuration programmatically
            to ensure that all loggers have been properly configured.
            </summary>
            <param name="purgeObsoleteLoggers">Purge garbage collected logger-items from the cache</param>
        </member>
        <member name="M:NLog.LogFactory.Flush">
            <summary>
            Flush any pending log messages (in case of asynchronous targets) with the default timeout of 15 seconds.
            </summary>
        </member>
        <member name="M:NLog.LogFactory.Flush(System.TimeSpan)">
            <summary>
            Flush any pending log messages (in case of asynchronous targets).
            </summary>
            <param name="timeout">Maximum time to allow for the flush. Any messages after that time
            will be discarded.</param>
        </member>
        <member name="M:NLog.LogFactory.Flush(System.Int32)">
            <summary>
            Flush any pending log messages (in case of asynchronous targets).
            </summary>
            <param name="timeoutMilliseconds">Maximum time to allow for the flush. Any messages
            after that time will be discarded.</param>
        </member>
        <member name="M:NLog.LogFactory.Flush(NLog.Common.AsyncContinuation)">
            <summary>
            Flush any pending log messages (in case of asynchronous targets).
            </summary>
            <param name="asyncContinuation">The asynchronous continuation.</param>
        </member>
        <member name="M:NLog.LogFactory.Flush(NLog.Common.AsyncContinuation,System.Int32)">
            <summary>
            Flush any pending log messages (in case of asynchronous targets).
            </summary>
            <param name="asyncContinuation">The asynchronous continuation.</param>
            <param name="timeoutMilliseconds">Maximum time to allow for the flush. Any messages
            after that time will be discarded.</param>
        </member>
        <member name="M:NLog.LogFactory.Flush(NLog.Common.AsyncContinuation,System.TimeSpan)">
            <summary>
            Flush any pending log messages (in case of asynchronous targets).
            </summary>
            <param name="asyncContinuation">The asynchronous continuation.</param>
            <param name="timeout">Maximum time to allow for the flush. Any messages after that time will be discarded.</param>
        </member>
        <member name="M:NLog.LogFactory.SuspendLogging">
            <summary>
            Suspends the logging, and returns object for using-scope so scope-exit calls <see cref="M:NLog.LogFactory.ResumeLogging"/>
            </summary>
            <remarks>
            Logging is suspended when the number of <see cref="M:NLog.LogFactory.SuspendLogging"/> calls are greater
            than the number of <see cref="M:NLog.LogFactory.ResumeLogging"/> calls.
            </remarks>
            <returns>An object that implements IDisposable whose Dispose() method re-enables logging.
            To be used with C# <c>using ()</c> statement.</returns>
        </member>
        <member name="M:NLog.LogFactory.ResumeLogging">
            <summary>
            Resumes logging if having called <see cref="M:NLog.LogFactory.SuspendLogging"/>.
            </summary>
            <remarks>
            Logging is suspended when the number of <see cref="M:NLog.LogFactory.SuspendLogging"/> calls are greater
            than the number of <see cref="M:NLog.LogFactory.ResumeLogging"/> calls.
            </remarks>
        </member>
        <member name="M:NLog.LogFactory.IsLoggingEnabled">
            <summary>
            Returns <see langword="true" /> if logging is currently enabled.
            </summary>
            <remarks>
            Logging is suspended when the number of <see cref="M:NLog.LogFactory.SuspendLogging"/> calls are greater
            than the number of <see cref="M:NLog.LogFactory.ResumeLogging"/> calls.
            </remarks>
            <returns>A value of <see langword="true" /> if logging is currently enabled,
            <see langword="false"/> otherwise.</returns>
        </member>
        <member name="M:NLog.LogFactory.OnConfigurationChanged(NLog.Config.LoggingConfigurationChangedEventArgs)">
            <summary>
            Raises the event when the configuration is reloaded.
            </summary>
            <param name="e">Event arguments.</param>
        </member>
        <member name="M:NLog.LogFactory.OnConfigurationReloaded(NLog.Config.LoggingConfigurationReloadedEventArgs)">
             <summary>
             Obsolete and replaced by <see cref="M:NLog.LogFactory.OnConfigurationReloaded(NLog.Config.LoggingConfigurationReloadedEventArgs)"/> with NLog 5.2.
            
             Raises the event when the configuration is reloaded.
             </summary>
             <param name="e">Event arguments</param>
        </member>
        <member name="M:NLog.LogFactory.BuildLoggerConfiguration(System.String,System.Collections.Generic.List{NLog.Config.LoggingRule})">
            <summary>
            Change this method with NLog v6 to completely disconnect LogFactory from Targets/Layouts
            - Remove LoggingRule-List-parameter
            - Return ITargetWithFilterChain[]
            </summary>
        </member>
        <member name="F:NLog.LogFactory._isDisposing">
            <summary>
            Currently this <see cref="T:NLog.LogFactory"/> is disposing?
            </summary>
        </member>
        <member name="M:NLog.LogFactory.Dispose(System.Boolean)">
            <summary>
            Releases unmanaged and - optionally - managed resources.
            </summary>
            <param name="disposing"><c>True</c> to release both managed and unmanaged resources;
            <c>false</c> to release only unmanaged resources.</param>
        </member>
        <member name="M:NLog.LogFactory.Shutdown">
            <summary>
            Dispose all targets, and shutdown logging.
            </summary>
        </member>
        <member name="M:NLog.LogFactory.GetCandidateConfigFilePaths">
             <summary>
             Obsolete and replaced by <see cref="M:NLog.LogManager.Setup"/> and <see cref="M:NLog.SetupBuilderExtensions.LoadConfigurationFromFile(NLog.Config.ISetupBuilder,System.String,System.Boolean)"/> with NLog v5.2.
            
             Get file paths (including filename) for the possible NLog config files.
             </summary>
             <returns>The file paths to the possible config file</returns>
        </member>
        <member name="M:NLog.LogFactory.GetCandidateConfigFilePaths(System.String)">
             <summary>
             Obsolete and replaced by <see cref="M:NLog.LogManager.Setup"/> and <see cref="M:NLog.SetupBuilderExtensions.LoadConfigurationFromFile(NLog.Config.ISetupBuilder,System.String,System.Boolean)"/> with NLog v5.2.
            
             Get file paths (including filename) for the possible NLog config files.
             </summary>
             <returns>The file paths to the possible config file</returns>
        </member>
        <member name="M:NLog.LogFactory.SetCandidateConfigFilePaths(System.Collections.Generic.IEnumerable{System.String})">
             <summary>
             Obsolete and replaced by <see cref="M:NLog.LogManager.Setup"/> and <see cref="M:NLog.SetupBuilderExtensions.LoadConfigurationFromFile(NLog.Config.ISetupBuilder,System.String,System.Boolean)"/> with NLog v5.2.
            
             Overwrite the candidates paths (including filename) for the possible NLog config files.
             </summary>
             <param name="filePaths">The file paths to the possible config file</param>
        </member>
        <member name="M:NLog.LogFactory.ResetCandidateConfigFilePath">
             <summary>
             Obsolete and replaced by <see cref="M:NLog.LogManager.Setup"/> and <see cref="M:NLog.SetupBuilderExtensions.LoadConfigurationFromFile(NLog.Config.ISetupBuilder,System.String,System.Boolean)"/> with NLog v5.2.
            
             Clear the candidate file paths and return to the defaults.
             </summary>
        </member>
        <member name="M:NLog.LogFactory.LoadConfiguration(System.String)">
             <summary>
             Obsolete and replaced by <see cref="M:NLog.LogManager.Setup"/> and <see cref="M:NLog.SetupBuilderExtensions.LoadConfigurationFromFile(NLog.Config.ISetupBuilder,System.String,System.Boolean)"/> with NLog v5.2.
            
             Loads logging configuration from file (Currently only XML configuration files supported)
             </summary>
             <param name="configFile">Configuration file to be read</param>
             <returns>LogFactory instance for fluent interface</returns>
        </member>
        <member name="T:NLog.LogFactory.LoggerCacheKey">
            <summary>
            Logger cache key.
            </summary>
        </member>
        <member name="M:NLog.LogFactory.LoggerCacheKey.GetHashCode">
            <summary>
            Serves as a hash function for a particular type.
            </summary>
        </member>
        <member name="M:NLog.LogFactory.LoggerCacheKey.Equals(System.Object)">
            <summary>
            Determines if two objects are equal in value.
            </summary>
            <param name="obj">Other object to compare to.</param>
            <returns>True if objects are equal, false otherwise.</returns>
        </member>
        <member name="M:NLog.LogFactory.LoggerCacheKey.Equals(NLog.LogFactory.LoggerCacheKey)">
            <summary>
            Determines if two objects of the same type are equal in value.
            </summary>
            <param name="other">Other object to compare to.</param>
            <returns>True if objects are equal, false otherwise.</returns>
        </member>
        <member name="T:NLog.LogFactory.LoggerCache">
            <summary>
            Logger cache.
            </summary>
        </member>
        <member name="M:NLog.LogFactory.LoggerCache.InsertOrUpdate(NLog.LogFactory.LoggerCacheKey,NLog.Logger)">
            <summary>
            Inserts or updates.
            </summary>
            <param name="cacheKey"></param>
            <param name="logger"></param>
        </member>
        <member name="M:NLog.LogFactory.LoggerCache.PurgeObsoleteLoggers">
            <summary>
            Loops through all cached loggers and removes dangling loggers that have been garbage collected.
            </summary>
        </member>
        <member name="M:NLog.LogFactory.ResetLoggerCache">
            <remarks>
            Internal for unit tests
            </remarks>
        </member>
        <member name="T:NLog.LogFactory.LogEnabler">
            <summary>
            Enables logging in <see cref="M:System.IDisposable.Dispose"/> implementation.
            </summary>
        </member>
        <member name="M:NLog.LogFactory.LogEnabler.#ctor(NLog.LogFactory)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.LogFactory.LogEnabler" /> class.
            </summary>
            <param name="factory">The factory.</param>
        </member>
        <member name="M:NLog.LogFactory.LogEnabler.System#IDisposable#Dispose">
            <summary>
            Enables logging.
            </summary>
        </member>
        <member name="T:NLog.Logger">
             <content>
             Logging methods which only are executed when the DEBUG conditional compilation symbol is set.
            
             Remarks:
             The DEBUG conditional compilation symbol is default enabled (only) in a debug build.
            
             If the DEBUG conditional compilation symbol isn't set in the calling library, the compiler will remove all the invocations to these methods.
             This could lead to better performance.
            
             See: https://msdn.microsoft.com/en-us/library/4xssyw96%28v=vs.90%29.aspx
             </content>
            <summary>
            Provides logging interface and utility functions.
            </summary>
            <content>
            Auto-generated Logger members for binary compatibility with NLog 1.0.
            </content>
            <summary>
            Provides logging interface and utility functions.
            </summary>
        </member>
        <member name="M:NLog.Logger.ConditionalDebug``1(``0)">
            <overloads>
            Writes the diagnostic message at the <c>Debug</c> level using the specified format provider and format parameters.
            </overloads>
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <typeparam name="T">Type of the value.</typeparam>
            <param name="value">The value to be written.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalDebug``1(System.IFormatProvider,``0)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <typeparam name="T">Type of the value.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="value">The value to be written.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalDebug(NLog.LogMessageGenerator)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="messageFunc">A function returning message to be written. Function is not evaluated if logging is not enabled.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalDebug(System.Exception,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message and exception at the <c>Debug</c> level.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalDebug(System.Exception,System.IFormatProvider,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message and exception at the <c>Debug</c> level.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalDebug(System.IFormatProvider,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified parameters and formatting them with the supplied format provider.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalDebug(System.String)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="message">Log message.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalDebug(System.String,System.Object[])">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified parameters.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalDebug``1(System.IFormatProvider,System.String,``0)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified parameter and formatting it with the supplied format provider.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <typeparam name="TArgument">The type of the argument.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalDebug``1(System.String,``0)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified parameter.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <typeparam name="TArgument">The type of the argument.</typeparam>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalDebug``2(System.IFormatProvider,System.String,``0,``1)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified arguments formatting it with the supplied format provider.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalDebug``2(System.String,``0,``1)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified parameters.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalDebug``3(System.IFormatProvider,System.String,``0,``1,``2)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified arguments formatting it with the supplied format provider.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <typeparam name="TArgument3">The type of the third argument.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
            <param name="argument3">The third argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalDebug``3(System.String,``0,``1,``2)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified parameters.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <typeparam name="TArgument3">The type of the third argument.</typeparam>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
            <param name="argument3">The third argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalDebug(System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="value">A <see langword="object" /> to be written.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalDebug(System.IFormatProvider,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="value">A <see langword="object" /> to be written.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalDebug(System.String,System.Object,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified parameters.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="arg1">First argument to format.</param>
            <param name="arg2">Second argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalDebug(System.String,System.Object,System.Object,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified parameters.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="arg1">First argument to format.</param>
            <param name="arg2">Second argument to format.</param>
            <param name="arg3">Third argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalDebug(System.IFormatProvider,System.String,System.Boolean)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalDebug(System.String,System.Boolean)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalDebug(System.IFormatProvider,System.String,System.Char)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalDebug(System.String,System.Char)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalDebug(System.IFormatProvider,System.String,System.Byte)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalDebug(System.String,System.Byte)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalDebug(System.IFormatProvider,System.String,System.String)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalDebug(System.String,System.String)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalDebug(System.IFormatProvider,System.String,System.Int32)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalDebug(System.String,System.Int32)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalDebug(System.IFormatProvider,System.String,System.Int64)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalDebug(System.String,System.Int64)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalDebug(System.IFormatProvider,System.String,System.Single)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalDebug(System.String,System.Single)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalDebug(System.IFormatProvider,System.String,System.Double)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalDebug(System.String,System.Double)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalDebug(System.IFormatProvider,System.String,System.Decimal)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalDebug(System.String,System.Decimal)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalDebug(System.IFormatProvider,System.String,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalDebug(System.String,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalTrace``1(``0)">
            <overloads>
            Writes the diagnostic message at the <c>Trace</c> level using the specified format provider and format parameters.
            </overloads>
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <typeparam name="T">Type of the value.</typeparam>
            <param name="value">The value to be written.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalTrace``1(System.IFormatProvider,``0)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <typeparam name="T">Type of the value.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="value">The value to be written.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalTrace(NLog.LogMessageGenerator)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="messageFunc">A function returning message to be written. Function is not evaluated if logging is not enabled.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalTrace(System.Exception,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message and exception at the <c>Trace</c> level.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalTrace(System.Exception,System.IFormatProvider,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message and exception at the <c>Trace</c> level.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalTrace(System.IFormatProvider,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified parameters and formatting them with the supplied format provider.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalTrace(System.String)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="message">Log message.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalTrace(System.String,System.Object[])">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified parameters.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalTrace``1(System.IFormatProvider,System.String,``0)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified parameter and formatting it with the supplied format provider.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <typeparam name="TArgument">The type of the argument.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalTrace``1(System.String,``0)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified parameter.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <typeparam name="TArgument">The type of the argument.</typeparam>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalTrace``2(System.IFormatProvider,System.String,``0,``1)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified arguments formatting it with the supplied format provider.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalTrace``2(System.String,``0,``1)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified parameters.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalTrace``3(System.IFormatProvider,System.String,``0,``1,``2)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified arguments formatting it with the supplied format provider.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <typeparam name="TArgument3">The type of the third argument.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
            <param name="argument3">The third argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalTrace``3(System.String,``0,``1,``2)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified parameters.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <typeparam name="TArgument3">The type of the third argument.</typeparam>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
            <param name="argument3">The third argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalTrace(System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="value">A <see langword="object" /> to be written.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalTrace(System.IFormatProvider,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="value">A <see langword="object" /> to be written.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalTrace(System.String,System.Object,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified parameters.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="arg1">First argument to format.</param>
            <param name="arg2">Second argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalTrace(System.String,System.Object,System.Object,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified parameters.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="arg1">First argument to format.</param>
            <param name="arg2">Second argument to format.</param>
            <param name="arg3">Third argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalTrace(System.IFormatProvider,System.String,System.Boolean)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalTrace(System.String,System.Boolean)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalTrace(System.IFormatProvider,System.String,System.Char)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalTrace(System.String,System.Char)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalTrace(System.IFormatProvider,System.String,System.Byte)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalTrace(System.String,System.Byte)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalTrace(System.IFormatProvider,System.String,System.String)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalTrace(System.String,System.String)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalTrace(System.IFormatProvider,System.String,System.Int32)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalTrace(System.String,System.Int32)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalTrace(System.IFormatProvider,System.String,System.Int64)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalTrace(System.String,System.Int64)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalTrace(System.IFormatProvider,System.String,System.Single)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalTrace(System.String,System.Single)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalTrace(System.IFormatProvider,System.String,System.Double)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalTrace(System.String,System.Double)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalTrace(System.IFormatProvider,System.String,System.Decimal)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalTrace(System.String,System.Decimal)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalTrace(System.IFormatProvider,System.String,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.ConditionalTrace(System.String,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter.
            Only executed when the DEBUG conditional compilation symbol is set.</summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="P:NLog.Logger.IsTraceEnabled">
            <summary>
            Gets a value indicating whether logging is enabled for the <c>Trace</c> level.
            </summary>
            <returns>A value of <see langword="true" /> if logging is enabled for the <c>Trace</c> level, otherwise it returns <see langword="false" />.</returns>
        </member>
        <member name="P:NLog.Logger.IsDebugEnabled">
            <summary>
            Gets a value indicating whether logging is enabled for the <c>Debug</c> level.
            </summary>
            <returns>A value of <see langword="true" /> if logging is enabled for the <c>Debug</c> level, otherwise it returns <see langword="false" />.</returns>
        </member>
        <member name="P:NLog.Logger.IsInfoEnabled">
            <summary>
            Gets a value indicating whether logging is enabled for the <c>Info</c> level.
            </summary>
            <returns>A value of <see langword="true" /> if logging is enabled for the <c>Info</c> level, otherwise it returns <see langword="false" />.</returns>
        </member>
        <member name="P:NLog.Logger.IsWarnEnabled">
            <summary>
            Gets a value indicating whether logging is enabled for the <c>Warn</c> level.
            </summary>
            <returns>A value of <see langword="true" /> if logging is enabled for the <c>Warn</c> level, otherwise it returns <see langword="false" />.</returns>
        </member>
        <member name="P:NLog.Logger.IsErrorEnabled">
            <summary>
            Gets a value indicating whether logging is enabled for the <c>Error</c> level.
            </summary>
            <returns>A value of <see langword="true" /> if logging is enabled for the <c>Error</c> level, otherwise it returns <see langword="false" />.</returns>
        </member>
        <member name="P:NLog.Logger.IsFatalEnabled">
            <summary>
            Gets a value indicating whether logging is enabled for the <c>Fatal</c> level.
            </summary>
            <returns>A value of <see langword="true" /> if logging is enabled for the <c>Fatal</c> level, otherwise it returns <see langword="false" />.</returns>
        </member>
        <member name="M:NLog.Logger.Trace``1(``0)">
            <overloads>
            Writes the diagnostic message at the <c>Trace</c> level using the specified format provider and format parameters.
            </overloads>
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level.
            </summary>
            <typeparam name="T">Type of the value.</typeparam>
            <param name="value">The value to be written.</param>
        </member>
        <member name="M:NLog.Logger.Trace``1(System.IFormatProvider,``0)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level.
            </summary>
            <typeparam name="T">Type of the value.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="value">The value to be written.</param>
        </member>
        <member name="M:NLog.Logger.Trace(NLog.LogMessageGenerator)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level.
            </summary>
            <param name="messageFunc">A function returning message to be written. Function is not evaluated if logging is not enabled.</param>
        </member>
        <member name="M:NLog.Logger.Trace(System.IFormatProvider,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified parameters and formatting them with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.Logger.Trace(System.String)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level.
            </summary>
            <param name="message">Log message.</param>
        </member>
        <member name="M:NLog.Logger.Trace(System.String,System.Object[])">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified parameters.
            </summary>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.Logger.Trace(System.Exception,System.String)">
            <summary>
            Writes the diagnostic message and exception at the <c>Trace</c> level.
            </summary>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
        </member>
        <member name="M:NLog.Logger.Trace(System.Exception,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message and exception at the <c>Trace</c> level.
            </summary>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.Logger.Trace(System.Exception,System.IFormatProvider,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message and exception at the <c>Trace</c> level.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.Logger.Trace``1(System.IFormatProvider,System.String,``0)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified parameter and formatting it with the supplied format provider.
            </summary>
            <typeparam name="TArgument">The type of the argument.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Trace``1(System.String,``0)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified parameter.
            </summary>
            <typeparam name="TArgument">The type of the argument.</typeparam>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Trace``2(System.IFormatProvider,System.String,``0,``1)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified arguments formatting it with the supplied format provider.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Trace``2(System.String,``0,``1)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified parameters.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Trace``3(System.IFormatProvider,System.String,``0,``1,``2)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified arguments formatting it with the supplied format provider.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <typeparam name="TArgument3">The type of the third argument.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
            <param name="argument3">The third argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Trace``3(System.String,``0,``1,``2)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified parameters.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <typeparam name="TArgument3">The type of the third argument.</typeparam>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
            <param name="argument3">The third argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Debug``1(``0)">
            <overloads>
            Writes the diagnostic message at the <c>Debug</c> level using the specified format provider and format parameters.
            </overloads>
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level.
            </summary>
            <typeparam name="T">Type of the value.</typeparam>
            <param name="value">The value to be written.</param>
        </member>
        <member name="M:NLog.Logger.Debug``1(System.IFormatProvider,``0)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level.
            </summary>
            <typeparam name="T">Type of the value.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="value">The value to be written.</param>
        </member>
        <member name="M:NLog.Logger.Debug(NLog.LogMessageGenerator)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level.
            </summary>
            <param name="messageFunc">A function returning message to be written. Function is not evaluated if logging is not enabled.</param>
        </member>
        <member name="M:NLog.Logger.Debug(System.IFormatProvider,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified parameters and formatting them with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.Logger.Debug(System.String)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level.
            </summary>
            <param name="message">Log message.</param>
        </member>
        <member name="M:NLog.Logger.Debug(System.String,System.Object[])">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified parameters.
            </summary>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.Logger.Debug(System.Exception,System.String)">
            <summary>
            Writes the diagnostic message and exception at the <c>Debug</c> level.
            </summary>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
        </member>
        <member name="M:NLog.Logger.Debug(System.Exception,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message and exception at the <c>Debug</c> level.
            </summary>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.Logger.Debug(System.Exception,System.IFormatProvider,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message and exception at the <c>Debug</c> level.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.Logger.Debug``1(System.IFormatProvider,System.String,``0)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified parameter and formatting it with the supplied format provider.
            </summary>
            <typeparam name="TArgument">The type of the argument.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Debug``1(System.String,``0)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified parameter.
            </summary>
            <typeparam name="TArgument">The type of the argument.</typeparam>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Debug``2(System.IFormatProvider,System.String,``0,``1)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified arguments formatting it with the supplied format provider.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Debug``2(System.String,``0,``1)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified parameters.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Debug``3(System.IFormatProvider,System.String,``0,``1,``2)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified arguments formatting it with the supplied format provider.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <typeparam name="TArgument3">The type of the third argument.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
            <param name="argument3">The third argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Debug``3(System.String,``0,``1,``2)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified parameters.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <typeparam name="TArgument3">The type of the third argument.</typeparam>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
            <param name="argument3">The third argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Info``1(``0)">
            <overloads>
            Writes the diagnostic message at the <c>Info</c> level using the specified format provider and format parameters.
            </overloads>
            <summary>
            Writes the diagnostic message at the <c>Info</c> level.
            </summary>
            <typeparam name="T">Type of the value.</typeparam>
            <param name="value">The value to be written.</param>
        </member>
        <member name="M:NLog.Logger.Info``1(System.IFormatProvider,``0)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level.
            </summary>
            <typeparam name="T">Type of the value.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="value">The value to be written.</param>
        </member>
        <member name="M:NLog.Logger.Info(NLog.LogMessageGenerator)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level.
            </summary>
            <param name="messageFunc">A function returning message to be written. Function is not evaluated if logging is not enabled.</param>
        </member>
        <member name="M:NLog.Logger.Info(System.IFormatProvider,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified parameters and formatting them with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.Logger.Info(System.String)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level.
            </summary>
            <param name="message">Log message.</param>
        </member>
        <member name="M:NLog.Logger.Info(System.String,System.Object[])">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified parameters.
            </summary>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.Logger.Info(System.Exception,System.String)">
            <summary>
            Writes the diagnostic message and exception at the <c>Info</c> level.
            </summary>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
        </member>
        <member name="M:NLog.Logger.Info(System.Exception,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message and exception at the <c>Info</c> level.
            </summary>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.Logger.Info(System.Exception,System.IFormatProvider,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message and exception at the <c>Info</c> level.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.Logger.Info``1(System.IFormatProvider,System.String,``0)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified parameter and formatting it with the supplied format provider.
            </summary>
            <typeparam name="TArgument">The type of the argument.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Info``1(System.String,``0)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified parameter.
            </summary>
            <typeparam name="TArgument">The type of the argument.</typeparam>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Info``2(System.IFormatProvider,System.String,``0,``1)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified arguments formatting it with the supplied format provider.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Info``2(System.String,``0,``1)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified parameters.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Info``3(System.IFormatProvider,System.String,``0,``1,``2)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified arguments formatting it with the supplied format provider.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <typeparam name="TArgument3">The type of the third argument.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
            <param name="argument3">The third argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Info``3(System.String,``0,``1,``2)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified parameters.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <typeparam name="TArgument3">The type of the third argument.</typeparam>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
            <param name="argument3">The third argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Warn``1(``0)">
            <overloads>
            Writes the diagnostic message at the <c>Warn</c> level using the specified format provider and format parameters.
            </overloads>
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level.
            </summary>
            <typeparam name="T">Type of the value.</typeparam>
            <param name="value">The value to be written.</param>
        </member>
        <member name="M:NLog.Logger.Warn``1(System.IFormatProvider,``0)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level.
            </summary>
            <typeparam name="T">Type of the value.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="value">The value to be written.</param>
        </member>
        <member name="M:NLog.Logger.Warn(NLog.LogMessageGenerator)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level.
            </summary>
            <param name="messageFunc">A function returning message to be written. Function is not evaluated if logging is not enabled.</param>
        </member>
        <member name="M:NLog.Logger.Warn(System.IFormatProvider,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified parameters and formatting them with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.Logger.Warn(System.String)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level.
            </summary>
            <param name="message">Log message.</param>
        </member>
        <member name="M:NLog.Logger.Warn(System.String,System.Object[])">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified parameters.
            </summary>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.Logger.Warn(System.Exception,System.String)">
            <summary>
            Writes the diagnostic message and exception at the <c>Warn</c> level.
            </summary>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
        </member>
        <member name="M:NLog.Logger.Warn(System.Exception,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message and exception at the <c>Warn</c> level.
            </summary>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.Logger.Warn(System.Exception,System.IFormatProvider,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message and exception at the <c>Warn</c> level.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.Logger.Warn``1(System.IFormatProvider,System.String,``0)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified parameter and formatting it with the supplied format provider.
            </summary>
            <typeparam name="TArgument">The type of the argument.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Warn``1(System.String,``0)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified parameter.
            </summary>
            <typeparam name="TArgument">The type of the argument.</typeparam>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Warn``2(System.IFormatProvider,System.String,``0,``1)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified arguments formatting it with the supplied format provider.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Warn``2(System.String,``0,``1)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified parameters.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Warn``3(System.IFormatProvider,System.String,``0,``1,``2)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified arguments formatting it with the supplied format provider.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <typeparam name="TArgument3">The type of the third argument.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
            <param name="argument3">The third argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Warn``3(System.String,``0,``1,``2)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified parameters.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <typeparam name="TArgument3">The type of the third argument.</typeparam>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
            <param name="argument3">The third argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Error``1(``0)">
            <overloads>
            Writes the diagnostic message at the <c>Error</c> level using the specified format provider and format parameters.
            </overloads>
            <summary>
            Writes the diagnostic message at the <c>Error</c> level.
            </summary>
            <typeparam name="T">Type of the value.</typeparam>
            <param name="value">The value to be written.</param>
        </member>
        <member name="M:NLog.Logger.Error``1(System.IFormatProvider,``0)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level.
            </summary>
            <typeparam name="T">Type of the value.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="value">The value to be written.</param>
        </member>
        <member name="M:NLog.Logger.Error(NLog.LogMessageGenerator)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level.
            </summary>
            <param name="messageFunc">A function returning message to be written. Function is not evaluated if logging is not enabled.</param>
        </member>
        <member name="M:NLog.Logger.Error(System.IFormatProvider,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified parameters and formatting them with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.Logger.Error(System.String)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level.
            </summary>
            <param name="message">Log message.</param>
        </member>
        <member name="M:NLog.Logger.Error(System.String,System.Object[])">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified parameters.
            </summary>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.Logger.Error(System.Exception,System.String)">
            <summary>
            Writes the diagnostic message and exception at the <c>Error</c> level.
            </summary>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
        </member>
        <member name="M:NLog.Logger.Error(System.Exception,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message and exception at the <c>Error</c> level.
            </summary>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.Logger.Error(System.Exception,System.IFormatProvider,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message and exception at the <c>Error</c> level.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.Logger.Error``1(System.IFormatProvider,System.String,``0)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified parameter and formatting it with the supplied format provider.
            </summary>
            <typeparam name="TArgument">The type of the argument.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Error``1(System.String,``0)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified parameter.
            </summary>
            <typeparam name="TArgument">The type of the argument.</typeparam>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Error``2(System.IFormatProvider,System.String,``0,``1)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified arguments formatting it with the supplied format provider.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Error``2(System.String,``0,``1)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified parameters.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Error``3(System.IFormatProvider,System.String,``0,``1,``2)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified arguments formatting it with the supplied format provider.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <typeparam name="TArgument3">The type of the third argument.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
            <param name="argument3">The third argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Error``3(System.String,``0,``1,``2)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified parameters.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <typeparam name="TArgument3">The type of the third argument.</typeparam>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
            <param name="argument3">The third argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Fatal``1(``0)">
            <overloads>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified format provider and format parameters.
            </overloads>
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level.
            </summary>
            <typeparam name="T">Type of the value.</typeparam>
            <param name="value">The value to be written.</param>
        </member>
        <member name="M:NLog.Logger.Fatal``1(System.IFormatProvider,``0)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level.
            </summary>
            <typeparam name="T">Type of the value.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="value">The value to be written.</param>
        </member>
        <member name="M:NLog.Logger.Fatal(NLog.LogMessageGenerator)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level.
            </summary>
            <param name="messageFunc">A function returning message to be written. Function is not evaluated if logging is not enabled.</param>
        </member>
        <member name="M:NLog.Logger.Fatal(System.IFormatProvider,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified parameters and formatting them with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.Logger.Fatal(System.String)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level.
            </summary>
            <param name="message">Log message.</param>
        </member>
        <member name="M:NLog.Logger.Fatal(System.String,System.Object[])">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified parameters.
            </summary>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.Logger.Fatal(System.Exception,System.String)">
            <summary>
            Writes the diagnostic message and exception at the <c>Fatal</c> level.
            </summary>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
        </member>
        <member name="M:NLog.Logger.Fatal(System.Exception,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message and exception at the <c>Fatal</c> level.
            </summary>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.Logger.Fatal(System.Exception,System.IFormatProvider,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message and exception at the <c>Fatal</c> level.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="exception">An exception to be logged.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.Logger.Fatal``1(System.IFormatProvider,System.String,``0)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified parameter and formatting it with the supplied format provider.
            </summary>
            <typeparam name="TArgument">The type of the argument.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Fatal``1(System.String,``0)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified parameter.
            </summary>
            <typeparam name="TArgument">The type of the argument.</typeparam>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Fatal``2(System.IFormatProvider,System.String,``0,``1)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified arguments formatting it with the supplied format provider.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Fatal``2(System.String,``0,``1)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified parameters.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Fatal``3(System.IFormatProvider,System.String,``0,``1,``2)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified arguments formatting it with the supplied format provider.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <typeparam name="TArgument3">The type of the third argument.</typeparam>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
            <param name="argument3">The third argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Fatal``3(System.String,``0,``1,``2)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified parameters.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <typeparam name="TArgument3">The type of the third argument.</typeparam>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
            <param name="argument3">The third argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Log(NLog.LogLevel,System.Object)">
            <summary>
            Writes the diagnostic message at the specified level.
            </summary>
            <param name="level">The log level.</param>
            <param name="value">A <see langword="object" /> to be written.</param>
        </member>
        <member name="M:NLog.Logger.Log(NLog.LogLevel,System.IFormatProvider,System.Object)">
            <summary>
            Writes the diagnostic message at the specified level.
            </summary>
            <param name="level">The log level.</param>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="value">A <see langword="object" /> to be written.</param>
        </member>
        <member name="M:NLog.Logger.Log(NLog.LogLevel,System.String,System.Object,System.Object)">
            <summary>
            Writes the diagnostic message at the specified level using the specified parameters.
            </summary>
            <param name="level">The log level.</param>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="arg1">First argument to format.</param>
            <param name="arg2">Second argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Log(NLog.LogLevel,System.String,System.Object,System.Object,System.Object)">
            <summary>
            Writes the diagnostic message at the specified level using the specified parameters.
            </summary>
            <param name="level">The log level.</param>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="arg1">First argument to format.</param>
            <param name="arg2">Second argument to format.</param>
            <param name="arg3">Third argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Log(NLog.LogLevel,System.IFormatProvider,System.String,System.Boolean)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="level">The log level.</param>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Log(NLog.LogLevel,System.String,System.Boolean)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter.
            </summary>
            <param name="level">The log level.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Log(NLog.LogLevel,System.IFormatProvider,System.String,System.Char)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="level">The log level.</param>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Log(NLog.LogLevel,System.String,System.Char)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter.
            </summary>
            <param name="level">The log level.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Log(NLog.LogLevel,System.IFormatProvider,System.String,System.Byte)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="level">The log level.</param>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Log(NLog.LogLevel,System.String,System.Byte)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter.
            </summary>
            <param name="level">The log level.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Log(NLog.LogLevel,System.IFormatProvider,System.String,System.String)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="level">The log level.</param>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Log(NLog.LogLevel,System.String,System.String)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter.
            </summary>
            <param name="level">The log level.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Log(NLog.LogLevel,System.IFormatProvider,System.String,System.Int32)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="level">The log level.</param>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Log(NLog.LogLevel,System.String,System.Int32)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter.
            </summary>
            <param name="level">The log level.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Log(NLog.LogLevel,System.IFormatProvider,System.String,System.Int64)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="level">The log level.</param>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Log(NLog.LogLevel,System.String,System.Int64)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter.
            </summary>
            <param name="level">The log level.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Log(NLog.LogLevel,System.IFormatProvider,System.String,System.Single)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="level">The log level.</param>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Log(NLog.LogLevel,System.String,System.Single)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter.
            </summary>
            <param name="level">The log level.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Log(NLog.LogLevel,System.IFormatProvider,System.String,System.Double)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="level">The log level.</param>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Log(NLog.LogLevel,System.String,System.Double)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter.
            </summary>
            <param name="level">The log level.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Log(NLog.LogLevel,System.IFormatProvider,System.String,System.Decimal)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="level">The log level.</param>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Log(NLog.LogLevel,System.String,System.Decimal)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter.
            </summary>
            <param name="level">The log level.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Log(NLog.LogLevel,System.IFormatProvider,System.String,System.Object)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="level">The log level.</param>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Log(NLog.LogLevel,System.String,System.Object)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter.
            </summary>
            <param name="level">The log level.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Log(NLog.LogLevel,System.IFormatProvider,System.String,System.SByte)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="level">The log level.</param>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Log(NLog.LogLevel,System.String,System.SByte)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter.
            </summary>
            <param name="level">The log level.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Log(NLog.LogLevel,System.IFormatProvider,System.String,System.UInt32)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="level">The log level.</param>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Log(NLog.LogLevel,System.String,System.UInt32)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter.
            </summary>
            <param name="level">The log level.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Log(NLog.LogLevel,System.IFormatProvider,System.String,System.UInt64)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="level">The log level.</param>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Log(NLog.LogLevel,System.String,System.UInt64)">
            <summary>
            Writes the diagnostic message at the specified level using the specified value as a parameter.
            </summary>
            <param name="level">The log level.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Trace(System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level.
            </summary>
            <param name="value">A <see langword="object" /> to be written.</param>
        </member>
        <member name="M:NLog.Logger.Trace(System.IFormatProvider,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="value">A <see langword="object" /> to be written.</param>
        </member>
        <member name="M:NLog.Logger.Trace(System.String,System.Object,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified parameters.
            </summary>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="arg1">First argument to format.</param>
            <param name="arg2">Second argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Trace(System.String,System.Object,System.Object,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified parameters.
            </summary>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="arg1">First argument to format.</param>
            <param name="arg2">Second argument to format.</param>
            <param name="arg3">Third argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Trace(System.IFormatProvider,System.String,System.Boolean)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Trace(System.String,System.Boolean)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Trace(System.IFormatProvider,System.String,System.Char)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Trace(System.String,System.Char)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Trace(System.IFormatProvider,System.String,System.Byte)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Trace(System.String,System.Byte)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Trace(System.IFormatProvider,System.String,System.String)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Trace(System.String,System.String)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Trace(System.IFormatProvider,System.String,System.Int32)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Trace(System.String,System.Int32)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Trace(System.IFormatProvider,System.String,System.Int64)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Trace(System.String,System.Int64)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Trace(System.IFormatProvider,System.String,System.Single)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Trace(System.String,System.Single)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Trace(System.IFormatProvider,System.String,System.Double)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Trace(System.String,System.Double)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Trace(System.IFormatProvider,System.String,System.Decimal)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Trace(System.String,System.Decimal)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Trace(System.IFormatProvider,System.String,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Trace(System.String,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Trace(System.IFormatProvider,System.String,System.SByte)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Trace(System.String,System.SByte)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Trace(System.IFormatProvider,System.String,System.UInt32)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Trace(System.String,System.UInt32)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Trace(System.IFormatProvider,System.String,System.UInt64)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Trace(System.String,System.UInt64)">
            <summary>
            Writes the diagnostic message at the <c>Trace</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Debug(System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level.
            </summary>
            <param name="value">A <see langword="object" /> to be written.</param>
        </member>
        <member name="M:NLog.Logger.Debug(System.IFormatProvider,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="value">A <see langword="object" /> to be written.</param>
        </member>
        <member name="M:NLog.Logger.Debug(System.String,System.Object,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified parameters.
            </summary>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="arg1">First argument to format.</param>
            <param name="arg2">Second argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Debug(System.String,System.Object,System.Object,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified parameters.
            </summary>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="arg1">First argument to format.</param>
            <param name="arg2">Second argument to format.</param>
            <param name="arg3">Third argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Debug(System.IFormatProvider,System.String,System.Boolean)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Debug(System.String,System.Boolean)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Debug(System.IFormatProvider,System.String,System.Char)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Debug(System.String,System.Char)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Debug(System.IFormatProvider,System.String,System.Byte)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Debug(System.String,System.Byte)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Debug(System.IFormatProvider,System.String,System.String)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Debug(System.String,System.String)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Debug(System.IFormatProvider,System.String,System.Int32)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Debug(System.String,System.Int32)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Debug(System.IFormatProvider,System.String,System.Int64)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Debug(System.String,System.Int64)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Debug(System.IFormatProvider,System.String,System.Single)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Debug(System.String,System.Single)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Debug(System.IFormatProvider,System.String,System.Double)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Debug(System.String,System.Double)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Debug(System.IFormatProvider,System.String,System.Decimal)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Debug(System.String,System.Decimal)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Debug(System.IFormatProvider,System.String,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Debug(System.String,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Debug(System.IFormatProvider,System.String,System.SByte)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Debug(System.String,System.SByte)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Debug(System.IFormatProvider,System.String,System.UInt32)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Debug(System.String,System.UInt32)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Debug(System.IFormatProvider,System.String,System.UInt64)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Debug(System.String,System.UInt64)">
            <summary>
            Writes the diagnostic message at the <c>Debug</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Info(System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level.
            </summary>
            <param name="value">A <see langword="object" /> to be written.</param>
        </member>
        <member name="M:NLog.Logger.Info(System.IFormatProvider,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="value">A <see langword="object" /> to be written.</param>
        </member>
        <member name="M:NLog.Logger.Info(System.String,System.Object,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified parameters.
            </summary>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="arg1">First argument to format.</param>
            <param name="arg2">Second argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Info(System.String,System.Object,System.Object,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified parameters.
            </summary>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="arg1">First argument to format.</param>
            <param name="arg2">Second argument to format.</param>
            <param name="arg3">Third argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Info(System.IFormatProvider,System.String,System.Boolean)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Info(System.String,System.Boolean)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Info(System.IFormatProvider,System.String,System.Char)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Info(System.String,System.Char)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Info(System.IFormatProvider,System.String,System.Byte)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Info(System.String,System.Byte)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Info(System.IFormatProvider,System.String,System.String)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Info(System.String,System.String)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Info(System.IFormatProvider,System.String,System.Int32)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Info(System.String,System.Int32)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Info(System.IFormatProvider,System.String,System.Int64)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Info(System.String,System.Int64)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Info(System.IFormatProvider,System.String,System.Single)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Info(System.String,System.Single)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Info(System.IFormatProvider,System.String,System.Double)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Info(System.String,System.Double)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Info(System.IFormatProvider,System.String,System.Decimal)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Info(System.String,System.Decimal)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Info(System.IFormatProvider,System.String,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Info(System.String,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Info(System.IFormatProvider,System.String,System.SByte)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Info(System.String,System.SByte)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Info(System.IFormatProvider,System.String,System.UInt32)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Info(System.String,System.UInt32)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Info(System.IFormatProvider,System.String,System.UInt64)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Info(System.String,System.UInt64)">
            <summary>
            Writes the diagnostic message at the <c>Info</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Warn(System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level.
            </summary>
            <param name="value">A <see langword="object" /> to be written.</param>
        </member>
        <member name="M:NLog.Logger.Warn(System.IFormatProvider,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="value">A <see langword="object" /> to be written.</param>
        </member>
        <member name="M:NLog.Logger.Warn(System.String,System.Object,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified parameters.
            </summary>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="arg1">First argument to format.</param>
            <param name="arg2">Second argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Warn(System.String,System.Object,System.Object,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified parameters.
            </summary>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="arg1">First argument to format.</param>
            <param name="arg2">Second argument to format.</param>
            <param name="arg3">Third argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Warn(System.IFormatProvider,System.String,System.Boolean)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Warn(System.String,System.Boolean)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Warn(System.IFormatProvider,System.String,System.Char)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Warn(System.String,System.Char)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Warn(System.IFormatProvider,System.String,System.Byte)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Warn(System.String,System.Byte)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Warn(System.IFormatProvider,System.String,System.String)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Warn(System.String,System.String)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Warn(System.IFormatProvider,System.String,System.Int32)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Warn(System.String,System.Int32)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Warn(System.IFormatProvider,System.String,System.Int64)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Warn(System.String,System.Int64)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Warn(System.IFormatProvider,System.String,System.Single)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Warn(System.String,System.Single)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Warn(System.IFormatProvider,System.String,System.Double)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Warn(System.String,System.Double)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Warn(System.IFormatProvider,System.String,System.Decimal)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Warn(System.String,System.Decimal)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Warn(System.IFormatProvider,System.String,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Warn(System.String,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Warn(System.IFormatProvider,System.String,System.SByte)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Warn(System.String,System.SByte)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Warn(System.IFormatProvider,System.String,System.UInt32)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Warn(System.String,System.UInt32)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Warn(System.IFormatProvider,System.String,System.UInt64)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Warn(System.String,System.UInt64)">
            <summary>
            Writes the diagnostic message at the <c>Warn</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Error(System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level.
            </summary>
            <param name="value">A <see langword="object" /> to be written.</param>
        </member>
        <member name="M:NLog.Logger.Error(System.IFormatProvider,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="value">A <see langword="object" /> to be written.</param>
        </member>
        <member name="M:NLog.Logger.Error(System.String,System.Object,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified parameters.
            </summary>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="arg1">First argument to format.</param>
            <param name="arg2">Second argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Error(System.String,System.Object,System.Object,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified parameters.
            </summary>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="arg1">First argument to format.</param>
            <param name="arg2">Second argument to format.</param>
            <param name="arg3">Third argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Error(System.IFormatProvider,System.String,System.Boolean)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Error(System.String,System.Boolean)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Error(System.IFormatProvider,System.String,System.Char)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Error(System.String,System.Char)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Error(System.IFormatProvider,System.String,System.Byte)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Error(System.String,System.Byte)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Error(System.IFormatProvider,System.String,System.String)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Error(System.String,System.String)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Error(System.IFormatProvider,System.String,System.Int32)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Error(System.String,System.Int32)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Error(System.IFormatProvider,System.String,System.Int64)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Error(System.String,System.Int64)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Error(System.IFormatProvider,System.String,System.Single)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Error(System.String,System.Single)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Error(System.IFormatProvider,System.String,System.Double)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Error(System.String,System.Double)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Error(System.IFormatProvider,System.String,System.Decimal)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Error(System.String,System.Decimal)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Error(System.IFormatProvider,System.String,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Error(System.String,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Error(System.IFormatProvider,System.String,System.SByte)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Error(System.String,System.SByte)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Error(System.IFormatProvider,System.String,System.UInt32)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Error(System.String,System.UInt32)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Error(System.IFormatProvider,System.String,System.UInt64)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Error(System.String,System.UInt64)">
            <summary>
            Writes the diagnostic message at the <c>Error</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Fatal(System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level.
            </summary>
            <param name="value">A <see langword="object" /> to be written.</param>
        </member>
        <member name="M:NLog.Logger.Fatal(System.IFormatProvider,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="value">A <see langword="object" /> to be written.</param>
        </member>
        <member name="M:NLog.Logger.Fatal(System.String,System.Object,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified parameters.
            </summary>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="arg1">First argument to format.</param>
            <param name="arg2">Second argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Fatal(System.String,System.Object,System.Object,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified parameters.
            </summary>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="arg1">First argument to format.</param>
            <param name="arg2">Second argument to format.</param>
            <param name="arg3">Third argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Fatal(System.IFormatProvider,System.String,System.Boolean)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Fatal(System.String,System.Boolean)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Fatal(System.IFormatProvider,System.String,System.Char)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Fatal(System.String,System.Char)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Fatal(System.IFormatProvider,System.String,System.Byte)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Fatal(System.String,System.Byte)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Fatal(System.IFormatProvider,System.String,System.String)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Fatal(System.String,System.String)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Fatal(System.IFormatProvider,System.String,System.Int32)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Fatal(System.String,System.Int32)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Fatal(System.IFormatProvider,System.String,System.Int64)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Fatal(System.String,System.Int64)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Fatal(System.IFormatProvider,System.String,System.Single)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Fatal(System.String,System.Single)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Fatal(System.IFormatProvider,System.String,System.Double)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Fatal(System.String,System.Double)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Fatal(System.IFormatProvider,System.String,System.Decimal)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Fatal(System.String,System.Decimal)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Fatal(System.IFormatProvider,System.String,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Fatal(System.String,System.Object)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Fatal(System.IFormatProvider,System.String,System.SByte)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Fatal(System.String,System.SByte)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Fatal(System.IFormatProvider,System.String,System.UInt32)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Fatal(System.String,System.UInt32)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Fatal(System.IFormatProvider,System.String,System.UInt64)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter and formatting it with the supplied format provider.
            </summary>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Fatal(System.String,System.UInt64)">
            <summary>
            Writes the diagnostic message at the <c>Fatal</c> level using the specified value as a parameter.
            </summary>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.TraceException(System.String,System.Exception)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Logger.DebugException(System.String,System.Exception)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Logger.InfoException(System.String,System.Exception)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Logger.WarnException(System.String,System.Exception)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Logger.ErrorException(System.String,System.Exception)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Logger.FatalException(System.String,System.Exception)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Logger.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Logger"/> class.
            </summary>
        </member>
        <member name="E:NLog.Logger.LoggerReconfigured">
            <summary>
            Occurs when logger configuration changes.
            </summary>
        </member>
        <member name="P:NLog.Logger.Name">
            <summary>
            Gets the name of the logger.
            </summary>
        </member>
        <member name="P:NLog.Logger.Factory">
            <summary>
            Gets the factory that created this logger.
            </summary>
        </member>
        <member name="P:NLog.Logger.Properties">
            <summary>
            Collection of context properties for the Logger. The logger will append it for all log events
            </summary>
            <remarks>
            It is recommended to use <see cref="M:NLog.Logger.WithProperty(System.String,System.Object)"/> for modifying context properties
            when same named logger is used at multiple locations or shared by different thread contexts.
            </remarks>
        </member>
        <member name="M:NLog.Logger.IsEnabled(NLog.LogLevel)">
            <summary>
            Gets a value indicating whether logging is enabled for the specified level.
            </summary>
            <param name="level">Log level to be checked.</param>
            <returns>A value of <see langword="true" /> if logging is enabled for the specified level, otherwise it returns <see langword="false" />.</returns>
        </member>
        <member name="M:NLog.Logger.WithProperty(System.String,System.Object)">
             <summary>
             Creates new logger that automatically appends the specified property to all log events (without changing current logger)
            
             With <see cref="P:NLog.Logger.Properties"/> property, all properties can be enumerated.
             </summary>
             <param name="propertyKey">Property Name</param>
             <param name="propertyValue">Property Value</param>
             <returns>New Logger object that automatically appends specified property</returns>
        </member>
        <member name="M:NLog.Logger.WithProperties(System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{System.String,System.Object}})">
             <summary>
             Creates new logger that automatically appends the specified properties to all log events (without changing current logger)
            
             With <see cref="P:NLog.Logger.Properties"/> property, all properties can be enumerated.
             </summary>
             <param name="properties">Collection of key-value pair properties</param>
             <returns>New Logger object that automatically appends specified properties</returns>
        </member>
        <member name="M:NLog.Logger.SetProperty(System.String,System.Object)">
             <summary>
             Obsolete and replaced by <see cref="M:NLog.Logger.WithProperty(System.String,System.Object)"/> that prevents unexpected side-effects in Logger-state.
            
             Updates the specified context property for the current logger. The logger will append it for all log events.
            
             With <see cref="P:NLog.Logger.Properties"/> property, all properties can be enumerated (or updated).
             </summary>
             <remarks>
             It is highly recommended to ONLY use <see cref="M:NLog.Logger.WithProperty(System.String,System.Object)"/> for modifying context properties.
             This method will affect all locations/contexts that makes use of the same named logger object. And can cause
             unexpected surprises at multiple locations and other thread contexts.
             </remarks>
             <param name="propertyKey">Property Name</param>
             <param name="propertyValue">Property Value</param>
        </member>
        <member name="M:NLog.Logger.PushScopeProperty(System.String,System.Object)">
            <summary>
            Updates the <see cref="T:NLog.ScopeContext"/> with provided property
            </summary>
            <param name="propertyName">Name of property</param>
            <param name="propertyValue">Value of property</param>
            <returns>A disposable object that removes the properties from logical context scope on dispose.</returns>
            <remarks><see cref="T:NLog.ScopeContext"/> property-dictionary-keys are case-insensitive</remarks>
        </member>
        <member name="M:NLog.Logger.PushScopeProperty``1(System.String,``0)">
            <summary>
            Updates the <see cref="T:NLog.ScopeContext"/> with provided property
            </summary>
            <param name="propertyName">Name of property</param>
            <param name="propertyValue">Value of property</param>
            <returns>A disposable object that removes the properties from logical context scope on dispose.</returns>
            <remarks><see cref="T:NLog.ScopeContext"/> property-dictionary-keys are case-insensitive</remarks>
        </member>
        <member name="M:NLog.Logger.PushScopeProperties(System.Collections.Generic.IReadOnlyCollection{System.Collections.Generic.KeyValuePair{System.String,System.Object}})">
            <summary>
            Updates the <see cref="T:NLog.ScopeContext"/> with provided properties
            </summary>
            <param name="scopeProperties">Properties being added to the scope dictionary</param>
            <returns>A disposable object that removes the properties from logical context scope on dispose.</returns>
            <remarks><see cref="T:NLog.ScopeContext"/> property-dictionary-keys are case-insensitive</remarks>
        </member>
        <member name="M:NLog.Logger.PushScopeProperties``1(System.Collections.Generic.IReadOnlyCollection{System.Collections.Generic.KeyValuePair{System.String,``0}})">
            <summary>
            Updates the <see cref="T:NLog.ScopeContext"/> with provided properties
            </summary>
            <param name="scopeProperties">Properties being added to the scope dictionary</param>
            <returns>A disposable object that removes the properties from logical context scope on dispose.</returns>
            <remarks><see cref="T:NLog.ScopeContext"/> property-dictionary-keys are case-insensitive</remarks>
        </member>
        <member name="M:NLog.Logger.PushScopeNested``1(``0)">
            <summary>
            Pushes new state on the logical context scope stack
            </summary>
            <param name="nestedState">Value to added to the scope stack</param>
            <returns>A disposable object that pops the nested scope state on dispose.</returns>
        </member>
        <member name="M:NLog.Logger.PushScopeNested(System.Object)">
            <summary>
            Pushes new state on the logical context scope stack
            </summary>
            <param name="nestedState">Value to added to the scope stack</param>
            <returns>A disposable object that pops the nested scope state on dispose.</returns>
        </member>
        <member name="M:NLog.Logger.Log(NLog.LogEventInfo)">
            <summary>
            Writes the specified diagnostic message.
            </summary>
            <param name="logEvent">Log event.</param>
        </member>
        <member name="M:NLog.Logger.Log(System.Type,NLog.LogEventInfo)">
            <summary>
            Writes the specified diagnostic message.
            </summary>
            <param name="wrapperType">Type of custom Logger wrapper.</param>
            <param name="logEvent">Log event.</param>
        </member>
        <member name="M:NLog.Logger.Log``1(NLog.LogLevel,``0)">
            <overloads>
            Writes the diagnostic message at the specified level using the specified format provider and format parameters.
            </overloads>
            <summary>
            Writes the diagnostic message at the specified level.
            </summary>
            <typeparam name="T">Type of the value.</typeparam>
            <param name="level">The log level.</param>
            <param name="value">The value to be written.</param>
        </member>
        <member name="M:NLog.Logger.Log``1(NLog.LogLevel,System.IFormatProvider,``0)">
            <summary>
            Writes the diagnostic message at the specified level.
            </summary>
            <typeparam name="T">Type of the value.</typeparam>
            <param name="level">The log level.</param>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="value">The value to be written.</param>
        </member>
        <member name="M:NLog.Logger.Log(NLog.LogLevel,NLog.LogMessageGenerator)">
            <summary>
            Writes the diagnostic message at the specified level.
            </summary>
            <param name="level">The log level.</param>
            <param name="messageFunc">A function returning message to be written. Function is not evaluated if logging is not enabled.</param>
        </member>
        <member name="M:NLog.Logger.Log(NLog.LogLevel,System.IFormatProvider,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message at the specified level using the specified parameters and formatting them with the supplied format provider.
            </summary>
            <param name="level">The log level.</param>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.Logger.Log(NLog.LogLevel,System.String)">
            <summary>
            Writes the diagnostic message at the specified level.
            </summary>
            <param name="level">The log level.</param>
            <param name="message">Log message.</param>
        </member>
        <member name="M:NLog.Logger.Log(NLog.LogLevel,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message at the specified level using the specified parameters.
            </summary>
            <param name="level">The log level.</param>
            <param name="message">A <see langword="string" /> containing format items.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.Logger.Log(NLog.LogLevel,System.Exception,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message and exception at the specified level.
            </summary>
            <param name="level">The log level.</param>
            <param name="exception">An exception to be logged.</param>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.Logger.Log(NLog.LogLevel,System.Exception,System.IFormatProvider,System.String,System.Object[])">
            <summary>
            Writes the diagnostic message and exception at the specified level.
            </summary>
            <param name="level">The log level.</param>
            <param name="exception">An exception to be logged.</param>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> to be written.</param>
            <param name="args">Arguments to format.</param>
        </member>
        <member name="M:NLog.Logger.Log``1(NLog.LogLevel,System.IFormatProvider,System.String,``0)">
            <summary>
            Writes the diagnostic message at the specified level using the specified parameter and formatting it with the supplied format provider.
            </summary>
            <typeparam name="TArgument">The type of the argument.</typeparam>
            <param name="level">The log level.</param>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Log``1(NLog.LogLevel,System.String,``0)">
            <summary>
            Writes the diagnostic message at the specified level using the specified parameter.
            </summary>
            <typeparam name="TArgument">The type of the argument.</typeparam>
            <param name="level">The log level.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument">The argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Log``2(NLog.LogLevel,System.IFormatProvider,System.String,``0,``1)">
            <summary>
            Writes the diagnostic message at the specified level using the specified arguments formatting it with the supplied format provider.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <param name="level">The log level.</param>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Log``2(NLog.LogLevel,System.String,``0,``1)">
            <summary>
            Writes the diagnostic message at the specified level using the specified parameters.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <param name="level">The log level.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Log``3(NLog.LogLevel,System.IFormatProvider,System.String,``0,``1,``2)">
            <summary>
            Writes the diagnostic message at the specified level using the specified arguments formatting it with the supplied format provider.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <typeparam name="TArgument3">The type of the third argument.</typeparam>
            <param name="level">The log level.</param>
            <param name="formatProvider">An IFormatProvider that supplies culture-specific formatting information.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
            <param name="argument3">The third argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Log``3(NLog.LogLevel,System.String,``0,``1,``2)">
            <summary>
            Writes the diagnostic message at the specified level using the specified parameters.
            </summary>
            <typeparam name="TArgument1">The type of the first argument.</typeparam>
            <typeparam name="TArgument2">The type of the second argument.</typeparam>
            <typeparam name="TArgument3">The type of the third argument.</typeparam>
            <param name="level">The log level.</param>
            <param name="message">A <see langword="string" /> containing one format item.</param>
            <param name="argument1">The first argument to format.</param>
            <param name="argument2">The second argument to format.</param>
            <param name="argument3">The third argument to format.</param>
        </member>
        <member name="M:NLog.Logger.Swallow(System.Action)">
            <summary>
            Runs the provided action. If the action throws, the exception is logged at <c>Error</c> level. The exception is not propagated outside of this method.
            </summary>
            <param name="action">Action to execute.</param>
        </member>
        <member name="M:NLog.Logger.Swallow``1(System.Func{``0})">
            <summary>
            Runs the provided function and returns its result. If an exception is thrown, it is logged at <c>Error</c> level.
            The exception is not propagated outside of this method; a default value is returned instead.
            </summary>
            <typeparam name="T">Return type of the provided function.</typeparam>
            <param name="func">Function to run.</param>
            <returns>Result returned by the provided function or the default value of type <typeparamref name="T"/> in case of exception.</returns>
        </member>
        <member name="M:NLog.Logger.Swallow``1(System.Func{``0},``0)">
            <summary>
            Runs the provided function and returns its result. If an exception is thrown, it is logged at <c>Error</c> level.
            The exception is not propagated outside of this method; a fallback value is returned instead.
            </summary>
            <typeparam name="T">Return type of the provided function.</typeparam>
            <param name="func">Function to run.</param>
            <param name="fallback">Fallback value to return in case of exception.</param>
            <returns>Result returned by the provided function or fallback value in case of exception.</returns>
        </member>
        <member name="M:NLog.Logger.Swallow(System.Threading.Tasks.Task)">
            <summary>
            Logs an exception is logged at <c>Error</c> level if the provided task does not run to completion.
            </summary>
            <param name="task">The task for which to log an error if it does not run to completion.</param>
            <remarks>This method is useful in fire-and-forget situations, where application logic does not depend on completion of task. This method is avoids C# warning CS4014 in such situations.</remarks>
        </member>
        <member name="M:NLog.Logger.SwallowAsync(System.Threading.Tasks.Task)">
            <summary>
            Returns a task that completes when a specified task to completes. If the task does not run to completion, an exception is logged at <c>Error</c> level. The returned task always runs to completion.
            </summary>
            <param name="task">The task for which to log an error if it does not run to completion.</param>
            <returns>A task that completes in the <see cref="F:System.Threading.Tasks.TaskStatus.RanToCompletion"/> state when <paramref name="task"/> completes.</returns>
        </member>
        <member name="M:NLog.Logger.SwallowAsync(System.Func{System.Threading.Tasks.Task})">
            <summary>
            Runs async action. If the action throws, the exception is logged at <c>Error</c> level. The exception is not propagated outside of this method.
            </summary>
            <param name="asyncAction">Async action to execute.</param>
        </member>
        <member name="M:NLog.Logger.SwallowAsync``1(System.Func{System.Threading.Tasks.Task{``0}})">
            <summary>
            Runs the provided async function and returns its result. If the task does not run to completion, an exception is logged at <c>Error</c> level.
            The exception is not propagated outside of this method; a default value is returned instead.
            </summary>
            <typeparam name="TResult">Return type of the provided function.</typeparam>
            <param name="asyncFunc">Async function to run.</param>
            <returns>A task that represents the completion of the supplied task. If the supplied task ends in the <see cref="F:System.Threading.Tasks.TaskStatus.RanToCompletion"/> state, the result of the new task will be the result of the supplied task; otherwise, the result of the new task will be the default value of type <typeparamref name="TResult"/>.</returns>
        </member>
        <member name="M:NLog.Logger.SwallowAsync``1(System.Func{System.Threading.Tasks.Task{``0}},``0)">
            <summary>
            Runs the provided async function and returns its result. If the task does not run to completion, an exception is logged at <c>Error</c> level.
            The exception is not propagated outside of this method; a fallback value is returned instead.
            </summary>
            <typeparam name="TResult">Return type of the provided function.</typeparam>
            <param name="asyncFunc">Async function to run.</param>
            <param name="fallback">Fallback value to return if the task does not end in the <see cref="F:System.Threading.Tasks.TaskStatus.RanToCompletion"/> state.</param>
            <returns>A task that represents the completion of the supplied task. If the supplied task ends in the <see cref="F:System.Threading.Tasks.TaskStatus.RanToCompletion"/> state, the result of the new task will be the result of the supplied task; otherwise, the result of the new task will be the fallback value.</returns>
        </member>
        <member name="M:NLog.Logger.OnLoggerReconfigured(System.EventArgs)">
            <summary>
            Raises the event when the logger is reconfigured.
            </summary>
            <param name="e">Event arguments</param>
        </member>
        <member name="T:NLog.LoggerImpl">
            <summary>
            Implementation of logging engine.
            </summary>
        </member>
        <member name="M:NLog.LoggerImpl.GetFilterResult(System.Collections.Generic.IList{NLog.Filters.Filter},NLog.LogEventInfo,NLog.Filters.FilterResult)">
            <summary>
            Gets the filter result.
            </summary>
            <param name="filterChain">The filter chain.</param>
            <param name="logEvent">The log event.</param>
            <param name="filterDefaultAction">default result if there are no filters, or none of the filters decides.</param>
            <returns>The result of the filter.</returns>
        </member>
        <member name="T:NLog.LogLevel">
            <summary>
            Defines available log levels.
            </summary>
            <remarks>
            Log levels ordered by severity:<br/>
            - <see cref="F:NLog.LogLevel.Trace"/> (Ordinal = 0) : Most verbose level. Used for development and seldom enabled in production.<br/>
            - <see cref="F:NLog.LogLevel.Debug"/> (Ordinal = 1) : Debugging the application behavior from internal events of interest.<br/>
            - <see cref="F:NLog.LogLevel.Info"/>  (Ordinal = 2) : Information that highlights progress or application lifetime events.<br/>
            - <see cref="F:NLog.LogLevel.Warn"/>  (Ordinal = 3) : Warnings about validation issues or temporary failures that can be recovered.<br/>
            - <see cref="F:NLog.LogLevel.Error"/> (Ordinal = 4) : Errors where functionality has failed or <see cref="T:System.Exception"/> have been caught.<br/>
            - <see cref="F:NLog.LogLevel.Fatal"/> (Ordinal = 5) : Most critical level. Application is about to abort.<br/>
            </remarks>
        </member>
        <member name="F:NLog.LogLevel.Trace">
            <summary>
            Trace log level (Ordinal = 0)
            </summary>
            <remarks>
            Most verbose level. Used for development and seldom enabled in production.
            </remarks>
        </member>
        <member name="F:NLog.LogLevel.Debug">
            <summary>
            Debug log level (Ordinal = 1)
            </summary>
            <remarks>
            Debugging the application behavior from internal events of interest.
            </remarks>
        </member>
        <member name="F:NLog.LogLevel.Info">
            <summary>
            Info log level (Ordinal = 2)
            </summary>
            <remarks>
            Information that highlights progress or application lifetime events.
            </remarks>
        </member>
        <member name="F:NLog.LogLevel.Warn">
            <summary>
            Warn log level (Ordinal = 3)
            </summary>
            <remarks>
            Warnings about validation issues or temporary failures that can be recovered.
            </remarks>
        </member>
        <member name="F:NLog.LogLevel.Error">
            <summary>
            Error log level (Ordinal = 4)
            </summary>
            <remarks>
            Errors where functionality has failed or <see cref="T:System.Exception"/> have been caught.
            </remarks>
        </member>
        <member name="F:NLog.LogLevel.Fatal">
            <summary>
            Fatal log level (Ordinal = 5)
            </summary>
            <remarks>
            Most critical level. Application is about to abort.
            </remarks>
        </member>
        <member name="F:NLog.LogLevel.Off">
            <summary>
            Off log level (Ordinal = 6)
            </summary>
        </member>
        <member name="P:NLog.LogLevel.AllLevels">
            <summary>
            Gets all the available log levels (Trace, Debug, Info, Warn, Error, Fatal, Off).
            </summary>
        </member>
        <member name="P:NLog.LogLevel.AllLoggingLevels">
            <summary>
             Gets all the log levels that can be used to log events (Trace, Debug, Info, Warn, Error, Fatal)
             i.e <c>LogLevel.Off</c> is excluded.
            </summary>
        </member>
        <member name="M:NLog.LogLevel.#ctor(System.String,System.Int32)">
            <summary>
            Initializes a new instance of <see cref="T:NLog.LogLevel"/>.
            </summary>
            <param name="name">The log level name.</param>
            <param name="ordinal">The log level ordinal number.</param>
        </member>
        <member name="P:NLog.LogLevel.Name">
            <summary>
            Gets the name of the log level.
            </summary>
        </member>
        <member name="P:NLog.LogLevel.Ordinal">
            <summary>
            Gets the ordinal of the log level.
            </summary>
        </member>
        <member name="M:NLog.LogLevel.op_Equality(NLog.LogLevel,NLog.LogLevel)">
            <summary>
            Compares two <see cref="T:NLog.LogLevel"/> objects
            and returns a value indicating whether
            the first one is equal to the second one.
            </summary>
            <param name="level1">The first level.</param>
            <param name="level2">The second level.</param>
            <returns>The value of <c>level1.Ordinal == level2.Ordinal</c>.</returns>
        </member>
        <member name="M:NLog.LogLevel.op_Inequality(NLog.LogLevel,NLog.LogLevel)">
            <summary>
            Compares two <see cref="T:NLog.LogLevel"/> objects
            and returns a value indicating whether
            the first one is not equal to the second one.
            </summary>
            <param name="level1">The first level.</param>
            <param name="level2">The second level.</param>
            <returns>The value of <c>level1.Ordinal != level2.Ordinal</c>.</returns>
        </member>
        <member name="M:NLog.LogLevel.op_GreaterThan(NLog.LogLevel,NLog.LogLevel)">
            <summary>
            Compares two <see cref="T:NLog.LogLevel"/> objects
            and returns a value indicating whether
            the first one is greater than the second one.
            </summary>
            <param name="level1">The first level.</param>
            <param name="level2">The second level.</param>
            <returns>The value of <c>level1.Ordinal &gt; level2.Ordinal</c>.</returns>
        </member>
        <member name="M:NLog.LogLevel.op_GreaterThanOrEqual(NLog.LogLevel,NLog.LogLevel)">
            <summary>
            Compares two <see cref="T:NLog.LogLevel"/> objects
            and returns a value indicating whether
            the first one is greater than or equal to the second one.
            </summary>
            <param name="level1">The first level.</param>
            <param name="level2">The second level.</param>
            <returns>The value of <c>level1.Ordinal &gt;= level2.Ordinal</c>.</returns>
        </member>
        <member name="M:NLog.LogLevel.op_LessThan(NLog.LogLevel,NLog.LogLevel)">
            <summary>
            Compares two <see cref="T:NLog.LogLevel"/> objects
            and returns a value indicating whether
            the first one is less than the second one.
            </summary>
            <param name="level1">The first level.</param>
            <param name="level2">The second level.</param>
            <returns>The value of <c>level1.Ordinal &lt; level2.Ordinal</c>.</returns>
        </member>
        <member name="M:NLog.LogLevel.op_LessThanOrEqual(NLog.LogLevel,NLog.LogLevel)">
            <summary>
            Compares two <see cref="T:NLog.LogLevel"/> objects
            and returns a value indicating whether
            the first one is less than or equal to the second one.
            </summary>
            <param name="level1">The first level.</param>
            <param name="level2">The second level.</param>
            <returns>The value of <c>level1.Ordinal &lt;= level2.Ordinal</c>.</returns>
        </member>
        <member name="M:NLog.LogLevel.FromOrdinal(System.Int32)">
            <summary>
            Gets the <see cref="T:NLog.LogLevel"/> that corresponds to the specified ordinal.
            </summary>
            <param name="ordinal">The ordinal.</param>
            <returns>The <see cref="T:NLog.LogLevel"/> instance. For 0 it returns <see cref="F:NLog.LogLevel.Trace"/>, 1 gives <see cref="F:NLog.LogLevel.Debug"/> and so on.</returns>
        </member>
        <member name="M:NLog.LogLevel.FromString(System.String)">
            <summary>
            Returns the <see cref="T:NLog.LogLevel"/> that corresponds to the supplied <see langword="string" />.
            </summary>
            <param name="levelName">The textual representation of the log level.</param>
            <returns>The enumeration value.</returns>
        </member>
        <member name="M:NLog.LogLevel.ToString">
            <summary>
            Returns a string representation of the log level.
            </summary>
            <returns>Log level name.</returns>
        </member>
        <member name="M:NLog.LogLevel.GetHashCode">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LogLevel.Equals(System.Object)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.LogLevel.Equals(NLog.LogLevel)">
            <summary>
            Determines whether the specified <see cref="T:NLog.LogLevel"/> instance is equal to this instance.
            </summary>
            <param name="other">The <see cref="T:NLog.LogLevel"/> to compare with this instance.</param>
            <returns>Value of <c>true</c> if the specified <see cref="T:NLog.LogLevel"/> is equal to
            this instance; otherwise, <c>false</c>.</returns>
        </member>
        <member name="M:NLog.LogLevel.CompareTo(System.Object)">
            <summary>
            Compares the level to the other <see cref="T:NLog.LogLevel"/> object.
            </summary>
            <param name="obj">The other object.</param>
            <returns>
            A value less than zero when this logger's <see cref="P:NLog.LogLevel.Ordinal"/> is
            less than the other logger's ordinal, 0 when they are equal and
            greater than zero when this ordinal is greater than the
            other ordinal.
            </returns>
        </member>
        <member name="M:NLog.LogLevel.CompareTo(NLog.LogLevel)">
            <summary>
            Compares the level to the other <see cref="T:NLog.LogLevel"/> object.
            </summary>
            <param name="other">The other object.</param>
            <returns>
            A value less than zero when this logger's <see cref="P:NLog.LogLevel.Ordinal"/> is
            less than the other logger's ordinal, 0 when they are equal and
            greater than zero when this ordinal is greater than the
            other ordinal.
            </returns>
        </member>
        <member name="T:NLog.Attributes.LogLevelTypeConverter">
            <summary>
            Support <see cref="T:NLog.LogLevel"/> implementation of <see cref="T:System.IConvertible"/>
            </summary>
        </member>
        <member name="M:NLog.Attributes.LogLevelTypeConverter.CanConvertFrom(System.ComponentModel.ITypeDescriptorContext,System.Type)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Attributes.LogLevelTypeConverter.ConvertFrom(System.ComponentModel.ITypeDescriptorContext,System.Globalization.CultureInfo,System.Object)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Attributes.LogLevelTypeConverter.CanConvertTo(System.ComponentModel.ITypeDescriptorContext,System.Type)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Attributes.LogLevelTypeConverter.ConvertTo(System.ComponentModel.ITypeDescriptorContext,System.Globalization.CultureInfo,System.Object,System.Type)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.LogManager">
            <summary>
            Creates and manages instances of <see cref="T:NLog.Logger" /> objects.
            </summary>
            <remarks>
            LogManager wraps a singleton instance of <see cref="T:NLog.LogFactory" />.
            </remarks>
        </member>
        <member name="P:NLog.LogManager.LogFactory">
            <summary>
            Gets the <see cref="T:NLog.LogFactory" /> instance used in the <see cref="T:NLog.LogManager"/>.
            </summary>
            <remarks>Could be used to pass the to other methods</remarks>
        </member>
        <member name="E:NLog.LogManager.ConfigurationChanged">
            <summary>
            Occurs when logging <see cref="P:NLog.LogManager.Configuration" /> changes. Both when assigned to new config or config unloaded.
            </summary>
            <remarks>
            Note <see cref="P:NLog.Config.LoggingConfigurationChangedEventArgs.ActivatedConfiguration"/> can be <c>null</c> when unloading configuration at shutdown.
            </remarks>
        </member>
        <member name="E:NLog.LogManager.ConfigurationReloaded">
            <summary>
            Obsolete and replaced by <see cref="E:NLog.LogManager.ConfigurationChanged"/> with NLog v5.2.
            Occurs when logging <see cref="P:NLog.LogManager.Configuration" /> gets reloaded.
            </summary>
        </member>
        <member name="P:NLog.LogManager.ThrowExceptions">
            <summary>
            Gets or sets a value indicating whether NLog should throw exceptions.
            By default exceptions are not thrown under any circumstances.
            </summary>
        </member>
        <member name="P:NLog.LogManager.ThrowConfigExceptions">
             <summary>
             Gets or sets a value indicating whether <see cref="T:NLog.NLogConfigurationException"/> should be thrown.
             </summary>
             <value>A value of <c>true</c> if exception should be thrown; otherwise, <c>false</c>.</value>
             <remarks>
             This option is for backwards-compatibility.
             By default exceptions are not thrown under any circumstances.
            
             </remarks>
        </member>
        <member name="P:NLog.LogManager.KeepVariablesOnReload">
            <summary>
            Gets or sets a value indicating whether Variables should be kept on configuration reload.
            </summary>
        </member>
        <member name="P:NLog.LogManager.AutoShutdown">
            <summary>
            Gets or sets a value indicating whether to automatically call <see cref="M:NLog.LogManager.Shutdown"/>
            on AppDomain.Unload or AppDomain.ProcessExit
            </summary>
        </member>
        <member name="P:NLog.LogManager.Configuration">
            <summary>
            Gets or sets the current logging configuration.
            </summary>
            <remarks>
            Setter will re-configure all <see cref="T:NLog.Logger"/>-objects, so no need to also call <see cref="M:NLog.LogManager.ReconfigExistingLoggers" />
            </remarks>
        </member>
        <member name="P:NLog.LogManager.GlobalThreshold">
            <summary>
            Gets or sets the global log threshold. Log events below this threshold are not logged.
            </summary>
        </member>
        <member name="M:NLog.LogManager.Setup">
            <summary>
            Begins configuration of the LogFactory options using fluent interface
            </summary>
        </member>
        <member name="M:NLog.LogManager.Setup(System.Action{NLog.Config.ISetupBuilder})">
            <summary>
            Begins configuration of the LogFactory options using fluent interface
            </summary>
        </member>
        <member name="M:NLog.LogManager.LoadConfiguration(System.String)">
            <summary>
            Obsolete and replaced by <see cref="M:NLog.LogManager.Setup"/> and <see cref="M:NLog.SetupBuilderExtensions.LoadConfigurationFromFile(NLog.Config.ISetupBuilder,System.String,System.Boolean)"/> with NLog v5.2.
            Loads logging configuration from file (Only XML configuration files supported)
            </summary>
            <param name="configFile">Configuration file to be read</param>
            <returns>LogFactory instance for fluent interface</returns>
        </member>
        <member name="M:NLog.LogManager.AddHiddenAssembly(System.Reflection.Assembly)">
            <summary>
            Adds the given assembly which will be skipped
            when NLog is trying to find the calling method on stack trace.
            </summary>
            <param name="assembly">The assembly to skip.</param>
        </member>
        <member name="M:NLog.LogManager.GetCurrentClassLogger">
            <summary>
            Gets the logger with the full name of the current class, so namespace and class name.
            </summary>
            <returns>The logger.</returns>
            <remarks>This method introduces performance hit, because of StackTrace capture.
            Make sure you are not calling this method in a loop.</remarks>
        </member>
        <member name="M:NLog.LogManager.GetCurrentClassLogger(System.Type)">
            <summary>
            Obsolete and replaced by <see cref="M:NLog.LogFactory.GetCurrentClassLogger``1"/> with NLog v5.2.
            Gets a custom logger with the full name of the current class, so namespace and class name.
            Use <paramref name="loggerType"/> to create instance of a custom <see cref="T:NLog.Logger"/>.
            If you haven't defined your own <see cref="T:NLog.Logger"/> class, then use the overload without the loggerType.
            </summary>
            <param name="loggerType">The type of the logger to create. The type must inherit from <see cref="T:NLog.Logger"/></param>
            <returns>The logger of type <paramref name="loggerType"/>.</returns>
            <remarks>This method introduces performance hit, because of StackTrace capture.
            Make sure you are not calling this method in a loop.</remarks>
        </member>
        <member name="M:NLog.LogManager.CreateNullLogger">
            <summary>
            Creates a logger that discards all log messages.
            </summary>
            <returns>Null logger which discards all log messages.</returns>
        </member>
        <member name="M:NLog.LogManager.GetLogger(System.String)">
            <summary>
            Gets the specified named logger.
            </summary>
            <param name="name">Name of the logger.</param>
            <returns>The logger reference. Multiple calls to <c>GetLogger</c> with the same argument aren't guaranteed to return the same logger reference.</returns>
        </member>
        <member name="M:NLog.LogManager.GetLogger(System.String,System.Type)">
            <summary>
            Obsolete and replaced by <see cref="M:NLog.LogFactory.GetLogger``1(System.String)"/> with NLog v5.2.
            Gets the specified named custom <see cref="T:NLog.Logger"/> using the parameter <paramref name="loggerType"/> for creating instance.
            If you haven't defined your own <see cref="T:NLog.Logger"/> class, then use the overload without the loggerType.
            </summary>
            <param name="name">Name of the logger.</param>
            <param name="loggerType">The logger class. This class must inherit from <see cref="T:NLog.Logger" />.</param>
            <returns>The logger of type <paramref name="loggerType"/>. Multiple calls to <c>GetLogger</c> with the same argument aren't guaranteed to return the same logger reference.</returns>
            <remarks>The generic way for this method is <see cref="M:NLog.LogFactory`1.GetLogger(System.String)"/></remarks>
        </member>
        <member name="M:NLog.LogManager.ReconfigExistingLoggers">
            <summary>
            Loops through all loggers previously returned by GetLogger.
            and recalculates their target and filter list. Useful after modifying the configuration programmatically
            to ensure that all loggers have been properly configured.
            </summary>
        </member>
        <member name="M:NLog.LogManager.ReconfigExistingLoggers(System.Boolean)">
            <summary>
            Loops through all loggers previously returned by GetLogger.
            and recalculates their target and filter list. Useful after modifying the configuration programmatically
            to ensure that all loggers have been properly configured.
            </summary>
            <param name="purgeObsoleteLoggers">Purge garbage collected logger-items from the cache</param>
        </member>
        <member name="M:NLog.LogManager.Flush">
            <summary>
            Flush any pending log messages (in case of asynchronous targets) with the default timeout of 15 seconds.
            </summary>
        </member>
        <member name="M:NLog.LogManager.Flush(System.TimeSpan)">
            <summary>
            Flush any pending log messages (in case of asynchronous targets).
            </summary>
            <param name="timeout">Maximum time to allow for the flush. Any messages after that time will be discarded.</param>
        </member>
        <member name="M:NLog.LogManager.Flush(System.Int32)">
            <summary>
            Flush any pending log messages (in case of asynchronous targets).
            </summary>
            <param name="timeoutMilliseconds">Maximum time to allow for the flush. Any messages after that time will be discarded.</param>
        </member>
        <member name="M:NLog.LogManager.Flush(NLog.Common.AsyncContinuation)">
            <summary>
            Flush any pending log messages (in case of asynchronous targets).
            </summary>
            <param name="asyncContinuation">The asynchronous continuation.</param>
        </member>
        <member name="M:NLog.LogManager.Flush(NLog.Common.AsyncContinuation,System.TimeSpan)">
            <summary>
            Flush any pending log messages (in case of asynchronous targets).
            </summary>
            <param name="asyncContinuation">The asynchronous continuation.</param>
            <param name="timeout">Maximum time to allow for the flush. Any messages after that time will be discarded.</param>
        </member>
        <member name="M:NLog.LogManager.Flush(NLog.Common.AsyncContinuation,System.Int32)">
            <summary>
            Flush any pending log messages (in case of asynchronous targets).
            </summary>
            <param name="asyncContinuation">The asynchronous continuation.</param>
            <param name="timeoutMilliseconds">Maximum time to allow for the flush. Any messages after that time will be discarded.</param>
        </member>
        <member name="M:NLog.LogManager.DisableLogging">
            <summary>
            Obsolete and replaced by by <see cref="M:NLog.LogManager.SuspendLogging"/> with NLog v5.
            Suspends the logging, and returns object for using-scope so scope-exit calls <see cref="M:NLog.LogManager.EnableLogging"/>
            </summary>
            <remarks>
            Logging is suspended when the number of <see cref="M:NLog.LogManager.DisableLogging"/> calls are greater
            than the number of <see cref="M:NLog.LogManager.EnableLogging"/> calls.
            </remarks>
            <returns>An object that implements IDisposable whose Dispose() method re-enables logging.
            To be used with C# <c>using ()</c> statement.</returns>
        </member>
        <member name="M:NLog.LogManager.EnableLogging">
            <summary>
            Obsolete and replaced by disposing the scope returned from <see cref="M:NLog.LogManager.SuspendLogging"/> with NLog v5.
            Resumes logging if having called <see cref="M:NLog.LogManager.DisableLogging"/>.
            </summary>
            <remarks>
            Logging is suspended when the number of <see cref="M:NLog.LogManager.DisableLogging"/> calls are greater
            than the number of <see cref="M:NLog.LogManager.EnableLogging"/> calls.
            </remarks>
        </member>
        <member name="M:NLog.LogManager.SuspendLogging">
            <summary>
            Suspends the logging, and returns object for using-scope so scope-exit calls <see cref="M:NLog.LogManager.ResumeLogging"/>
            </summary>
            <remarks>
            Logging is suspended when the number of <see cref="M:NLog.LogManager.SuspendLogging"/> calls are greater
            than the number of <see cref="M:NLog.LogManager.ResumeLogging"/> calls.
            </remarks>
            <returns>An object that implements IDisposable whose Dispose() method re-enables logging.
            To be used with C# <c>using ()</c> statement.</returns>
        </member>
        <member name="M:NLog.LogManager.ResumeLogging">
            <summary>
            Resumes logging if having called <see cref="M:NLog.LogManager.SuspendLogging"/>.
            </summary>
            <remarks>
            Logging is suspended when the number of <see cref="M:NLog.LogManager.SuspendLogging"/> calls are greater
            than the number of <see cref="M:NLog.LogManager.ResumeLogging"/> calls.
            </remarks>
        </member>
        <member name="M:NLog.LogManager.IsLoggingEnabled">
            <summary>
            Returns <see langword="true" /> if logging is currently enabled.
            </summary>
            <remarks>
            Logging is suspended when the number of <see cref="M:NLog.LogManager.SuspendLogging"/> calls are greater
            than the number of <see cref="M:NLog.LogManager.ResumeLogging"/> calls.
            </remarks>
            <returns>A value of <see langword="true" /> if logging is currently enabled,
            <see langword="false"/> otherwise.</returns>
        </member>
        <member name="M:NLog.LogManager.Shutdown">
            <summary>
            Dispose all targets, and shutdown logging.
            </summary>
        </member>
        <member name="T:NLog.LogMessageFormatter">
            <summary>
            Generates a formatted message from the log event
            </summary>
            <param name="logEvent">Log event.</param>
            <returns>Formatted message</returns>
        </member>
        <member name="T:NLog.LogMessageGenerator">
            <summary>
            Returns a log message. Used to defer calculation of
            the log message until it's actually needed.
            </summary>
            <returns>Log message.</returns>
        </member>
        <member name="T:NLog.MappedDiagnosticsContext">
             <summary>
             Obsolete and replaced by <see cref="T:NLog.ScopeContext"/> with NLog v5.
            
             Mapped Diagnostics Context (MDC) is a dictionary of keys and values.
             Stores the dictionary in the thread-local static variable, and provides methods to output dictionary values in layouts.
             </summary>
        </member>
        <member name="M:NLog.MappedDiagnosticsContext.SetScoped(System.String,System.String)">
            <summary>
            Sets the current thread MDC item to the specified value.
            </summary>
            <param name="item">Item name.</param>
            <param name="value">Item value.</param>
            <returns>An <see cref="T:System.IDisposable"/> that can be used to remove the item from the current thread MDC.</returns>
        </member>
        <member name="M:NLog.MappedDiagnosticsContext.SetScoped(System.String,System.Object)">
            <summary>
            Sets the current thread MDC item to the specified value.
            </summary>
            <param name="item">Item name.</param>
            <param name="value">Item value.</param>
            <returns>>An <see cref="T:System.IDisposable"/> that can be used to remove the item from the current thread MDC.</returns>
        </member>
        <member name="M:NLog.MappedDiagnosticsContext.Set(System.String,System.String)">
            <summary>
            Sets the current thread MDC item to the specified value.
            </summary>
            <param name="item">Item name.</param>
            <param name="value">Item value.</param>
        </member>
        <member name="M:NLog.MappedDiagnosticsContext.Set(System.String,System.Object)">
            <summary>
            Sets the current thread MDC item to the specified value.
            </summary>
            <param name="item">Item name.</param>
            <param name="value">Item value.</param>
        </member>
        <member name="M:NLog.MappedDiagnosticsContext.Get(System.String)">
            <summary>
            Gets the current thread MDC named item, as <see cref="T:System.String"/>.
            </summary>
            <param name="item">Item name.</param>
            <returns>The value of <paramref name="item"/>, if defined; otherwise <see cref="F:System.String.Empty"/>.</returns>
            <remarks>If the value isn't a <see cref="T:System.String"/> already, this call locks the <see cref="T:NLog.LogFactory"/> for reading the <see cref="P:NLog.Config.LoggingConfiguration.DefaultCultureInfo"/> needed for converting to <see cref="T:System.String"/>. </remarks>
        </member>
        <member name="M:NLog.MappedDiagnosticsContext.Get(System.String,System.IFormatProvider)">
            <summary>
            Gets the current thread MDC named item, as <see cref="T:System.String"/>.
            </summary>
            <param name="item">Item name.</param>
            <param name="formatProvider">The <see cref="T:System.IFormatProvider"/> to use when converting a value to a <see cref="T:System.String"/>.</param>
            <returns>The value of <paramref name="item"/>, if defined; otherwise <see cref="F:System.String.Empty"/>.</returns>
            <remarks>If <paramref name="formatProvider"/> is <c>null</c> and the value isn't a <see cref="T:System.String"/> already, this call locks the <see cref="T:NLog.LogFactory"/> for reading the <see cref="P:NLog.Config.LoggingConfiguration.DefaultCultureInfo"/> needed for converting to <see cref="T:System.String"/>. </remarks>
        </member>
        <member name="M:NLog.MappedDiagnosticsContext.GetObject(System.String)">
            <summary>
            Gets the current thread MDC named item, as <see cref="T:System.Object"/>.
            </summary>
            <param name="item">Item name.</param>
            <returns>The value of <paramref name="item"/>, if defined; otherwise <c>null</c>.</returns>
        </member>
        <member name="M:NLog.MappedDiagnosticsContext.GetNames">
            <summary>
            Returns all item names
            </summary>
            <returns>A set of the names of all items in current thread-MDC.</returns>
        </member>
        <member name="M:NLog.MappedDiagnosticsContext.Contains(System.String)">
            <summary>
            Checks whether the specified item exists in current thread MDC.
            </summary>
            <param name="item">Item name.</param>
            <returns>A boolean indicating whether the specified <paramref name="item"/> exists in current thread MDC.</returns>
        </member>
        <member name="M:NLog.MappedDiagnosticsContext.Remove(System.String)">
            <summary>
            Removes the specified <paramref name="item"/> from current thread MDC.
            </summary>
            <param name="item">Item name.</param>
        </member>
        <member name="M:NLog.MappedDiagnosticsContext.Clear">
            <summary>
            Clears the content of current thread MDC.
            </summary>
        </member>
        <member name="T:NLog.MappedDiagnosticsLogicalContext">
             <summary>
             Obsolete and replaced by <see cref="T:NLog.ScopeContext"/> with NLog v5.
            
             Mapped Diagnostics Logical Context (MDLC) is a dictionary of keys and values.
             Stores the dictionary in the logical thread callcontext, and provides methods to output dictionary values in layouts.
             Allows for maintaining state across asynchronous tasks and call contexts.
             </summary>
             <remarks>
             Ideally, these changes should be incorporated as a new version of the MappedDiagnosticsContext class in the original
             NLog library so that state can be maintained for multiple threads in asynchronous situations.
             </remarks>
        </member>
        <member name="M:NLog.MappedDiagnosticsLogicalContext.Get(System.String)">
            <summary>
            Gets the current logical context named item, as <see cref="T:System.String"/>.
            </summary>
            <param name="item">Item name.</param>
            <returns>The value of <paramref name="item"/>, if defined; otherwise <see cref="F:System.String.Empty"/>.</returns>
            <remarks>If the value isn't a <see cref="T:System.String"/> already, this call locks the <see cref="T:NLog.LogFactory"/> for reading the <see cref="P:NLog.Config.LoggingConfiguration.DefaultCultureInfo"/> needed for converting to <see cref="T:System.String"/>. </remarks>
        </member>
        <member name="M:NLog.MappedDiagnosticsLogicalContext.Get(System.String,System.IFormatProvider)">
            <summary>
            Gets the current logical context named item, as <see cref="T:System.String"/>.
            </summary>
            <param name="item">Item name.</param>
            <param name="formatProvider">The <see cref="T:System.IFormatProvider"/> to use when converting a value to a string.</param>
            <returns>The value of <paramref name="item"/>, if defined; otherwise <see cref="F:System.String.Empty"/>.</returns>
            <remarks>If <paramref name="formatProvider"/> is <c>null</c> and the value isn't a <see cref="T:System.String"/> already, this call locks the <see cref="T:NLog.LogFactory"/> for reading the <see cref="P:NLog.Config.LoggingConfiguration.DefaultCultureInfo"/> needed for converting to <see cref="T:System.String"/>. </remarks>
        </member>
        <member name="M:NLog.MappedDiagnosticsLogicalContext.GetObject(System.String)">
            <summary>
            Gets the current logical context named item, as <see cref="T:System.Object"/>.
            </summary>
            <param name="item">Item name.</param>
            <returns>The value of <paramref name="item"/>, if defined; otherwise <c>null</c>.</returns>
        </member>
        <member name="M:NLog.MappedDiagnosticsLogicalContext.SetScoped(System.String,System.String)">
            <summary>
            Sets the current logical context item to the specified value.
            </summary>
            <param name="item">Item name.</param>
            <param name="value">Item value.</param>
            <returns>>An <see cref="T:System.IDisposable"/> that can be used to remove the item from the current logical context.</returns>
        </member>
        <member name="M:NLog.MappedDiagnosticsLogicalContext.SetScoped(System.String,System.Object)">
            <summary>
            Sets the current logical context item to the specified value.
            </summary>
            <param name="item">Item name.</param>
            <param name="value">Item value.</param>
            <returns>>An <see cref="T:System.IDisposable"/> that can be used to remove the item from the current logical context.</returns>
        </member>
        <member name="M:NLog.MappedDiagnosticsLogicalContext.SetScoped``1(System.String,``0)">
            <summary>
            Sets the current logical context item to the specified value.
            </summary>
            <param name="item">Item name.</param>
            <param name="value">Item value.</param>
            <returns>>An <see cref="T:System.IDisposable"/> that can be used to remove the item from the current logical context.</returns>
        </member>
        <member name="M:NLog.MappedDiagnosticsLogicalContext.SetScoped(System.Collections.Generic.IReadOnlyList{System.Collections.Generic.KeyValuePair{System.String,System.Object}})">
            <summary>
            Updates the current logical context with multiple items in single operation
            </summary>
            <param name="items">.</param>
            <returns>>An <see cref="T:System.IDisposable"/> that can be used to remove the item from the current logical context (null if no items).</returns>
        </member>
        <member name="M:NLog.MappedDiagnosticsLogicalContext.Set(System.String,System.String)">
            <summary>
            Sets the current logical context item to the specified value.
            </summary>
            <param name="item">Item name.</param>
            <param name="value">Item value.</param>
        </member>
        <member name="M:NLog.MappedDiagnosticsLogicalContext.Set(System.String,System.Object)">
            <summary>
            Sets the current logical context item to the specified value.
            </summary>
            <param name="item">Item name.</param>
            <param name="value">Item value.</param>
        </member>
        <member name="M:NLog.MappedDiagnosticsLogicalContext.Set``1(System.String,``0)">
            <summary>
            Sets the current logical context item to the specified value.
            </summary>
            <param name="item">Item name.</param>
            <param name="value">Item value.</param>
        </member>
        <member name="M:NLog.MappedDiagnosticsLogicalContext.GetNames">
            <summary>
            Returns all item names
            </summary>
            <returns>A collection of the names of all items in current logical context.</returns>
        </member>
        <member name="M:NLog.MappedDiagnosticsLogicalContext.Contains(System.String)">
            <summary>
            Checks whether the specified <paramref name="item"/> exists in current logical context.
            </summary>
            <param name="item">Item name.</param>
            <returns>A boolean indicating whether the specified <paramref name="item"/> exists in current logical context.</returns>
        </member>
        <member name="M:NLog.MappedDiagnosticsLogicalContext.Remove(System.String)">
            <summary>
            Removes the specified <paramref name="item"/> from current logical context.
            </summary>
            <param name="item">Item name.</param>
        </member>
        <member name="M:NLog.MappedDiagnosticsLogicalContext.Clear">
            <summary>
            Clears the content of current logical context.
            </summary>
        </member>
        <member name="M:NLog.MappedDiagnosticsLogicalContext.Clear(System.Boolean)">
            <summary>
            Clears the content of current logical context.
            </summary>
            <param name="free">Free the full slot.</param>
        </member>
        <member name="T:NLog.MessageTemplateFormatMethodAttribute">
            <summary>
            Mark a parameter of a method for message templating
            </summary>
        </member>
        <member name="M:NLog.MessageTemplateFormatMethodAttribute.#ctor(System.String)">
            <param name="parameterName">
            Specifies which parameter of an annotated method should be treated as message-template-string
            </param>
        </member>
        <member name="P:NLog.MessageTemplateFormatMethodAttribute.ParameterName">
            <summary>
            The name of the parameter that should be as treated as message-template-string
            </summary>
        </member>
        <member name="T:NLog.MessageTemplates.CaptureType">
            <summary>
            The type of the captured hole
            </summary>
        </member>
        <member name="F:NLog.MessageTemplates.CaptureType.Unknown">
            <summary>
            Not decided
            </summary>
        </member>
        <member name="F:NLog.MessageTemplates.CaptureType.Normal">
            <summary>
            normal {x}
            </summary>
        </member>
        <member name="F:NLog.MessageTemplates.CaptureType.Serialize">
            <summary>
             Serialize operator {@x} (aka destructure)
            </summary>
        </member>
        <member name="F:NLog.MessageTemplates.CaptureType.Stringify">
            <summary>
            stringification operator {$x}
            </summary>
        </member>
        <member name="T:NLog.MessageTemplates.Hole">
            <summary>
            A hole that will be replaced with a value
            </summary>
        </member>
        <member name="M:NLog.MessageTemplates.Hole.#ctor(System.String,System.String,NLog.MessageTemplates.CaptureType,System.Int16,System.Int16)">
            <summary>
            Constructor
            </summary>
        </member>
        <member name="F:NLog.MessageTemplates.Hole.Name">
            <summary>Parameter name sent to structured loggers.</summary>
            <remarks>This is everything between "{" and the first of ",:}".
            Including surrounding spaces and names that are numbers.</remarks>
        </member>
        <member name="F:NLog.MessageTemplates.Hole.Format">
            <summary>Format to render the parameter.</summary>
            <remarks>This is everything between ":" and the first unescaped "}"</remarks>
        </member>
        <member name="F:NLog.MessageTemplates.Hole.CaptureType">
            <summary>
            Type
            </summary>
        </member>
        <member name="F:NLog.MessageTemplates.Hole.Index">
            <summary>When the template is positional, this is the parsed name of this parameter.</summary>
            <remarks>For named templates, the value of Index is undefined.</remarks>
        </member>
        <member name="F:NLog.MessageTemplates.Hole.Alignment">
            <summary>Alignment to render the parameter, by default 0.</summary>
            <remarks>This is the parsed value between "," and the first of ":}"</remarks>
        </member>
        <member name="T:NLog.MessageTemplates.Literal">
            <summary>
            A fixed value
            </summary>
        </member>
        <member name="F:NLog.MessageTemplates.Literal.Print">
            <summary>Number of characters from the original template to copy at the current position.</summary>
            <remarks>This can be 0 when the template starts with a hole or when there are multiple consecutive holes.</remarks>
        </member>
        <member name="F:NLog.MessageTemplates.Literal.Skip">
            <summary>Number of characters to skip in the original template at the current position.</summary>
            <remarks>0 is a special value that mean: 1 escaped char, no hole. It can also happen last when the template ends with a literal.</remarks>
        </member>
        <member name="T:NLog.MessageTemplates.LiteralHole">
            <summary>
            Combines Literal and Hole
            </summary>
        </member>
        <member name="F:NLog.MessageTemplates.LiteralHole.Literal">
            <summary>Literal</summary>
        </member>
        <member name="F:NLog.MessageTemplates.LiteralHole.Hole">
            <summary>Hole</summary>
            <remarks>Uninitialized when <see cref="F:NLog.MessageTemplates.Literal.Skip"/> = 0.</remarks>
        </member>
        <member name="T:NLog.MessageTemplates.MessageTemplateParameter">
            <summary>
            Description of a single parameter extracted from a MessageTemplate
            </summary>
        </member>
        <member name="P:NLog.MessageTemplates.MessageTemplateParameter.Name">
            <summary>
            Parameter Name extracted from <see cref="P:NLog.LogEventInfo.Message"/>
            This is everything between "{" and the first of ",:}".
            </summary>
        </member>
        <member name="P:NLog.MessageTemplates.MessageTemplateParameter.Value">
            <summary>
            Parameter Value extracted from the <see cref="P:NLog.LogEventInfo.Parameters"/>-array
            </summary>
        </member>
        <member name="P:NLog.MessageTemplates.MessageTemplateParameter.Format">
            <summary>
            Format to render the parameter.
            This is everything between ":" and the first unescaped "}"
            </summary>
        </member>
        <member name="P:NLog.MessageTemplates.MessageTemplateParameter.CaptureType">
            <summary>
            Parameter method that should be used to render the parameter
            See also <see cref="T:NLog.IValueFormatter"/>
            </summary>
        </member>
        <member name="P:NLog.MessageTemplates.MessageTemplateParameter.PositionalIndex">
            <summary>
            Returns index for <see cref="P:NLog.LogEventInfo.Parameters"/>, when <see cref="P:NLog.MessageTemplates.MessageTemplateParameters.IsPositional"/>
            </summary>
        </member>
        <member name="M:NLog.MessageTemplates.MessageTemplateParameter.#ctor(System.String,System.Object,System.String)">
            <summary>
            Constructs a single message template parameter
            </summary>
            <param name="name">Parameter Name</param>
            <param name="value">Parameter Value</param>
            <param name="format">Parameter Format</param>
        </member>
        <member name="M:NLog.MessageTemplates.MessageTemplateParameter.#ctor(System.String,System.Object,System.String,NLog.MessageTemplates.CaptureType)">
            <summary>
            Constructs a single message template parameter
            </summary>
            <param name="name">Parameter Name</param>
            <param name="value">Parameter Value</param>
            <param name="format">Parameter Format</param>
            <param name="captureType">Parameter CaptureType</param>
        </member>
        <member name="T:NLog.MessageTemplates.MessageTemplateParameters">
            <summary>
            Parameters extracted from parsing <see cref="P:NLog.LogEventInfo.Message"/> as MessageTemplate
            </summary>
        </member>
        <member name="M:NLog.MessageTemplates.MessageTemplateParameters.GetEnumerator">
            <inheritDoc/>
        </member>
        <member name="M:NLog.MessageTemplates.MessageTemplateParameters.System#Collections#IEnumerable#GetEnumerator">
            <inheritDoc/>
        </member>
        <member name="P:NLog.MessageTemplates.MessageTemplateParameters.Item(System.Int32)">
            <summary>
            Gets the parameters at the given index
            </summary>
        </member>
        <member name="P:NLog.MessageTemplates.MessageTemplateParameters.Count">
            <summary>
            Number of parameters
            </summary>
        </member>
        <member name="P:NLog.MessageTemplates.MessageTemplateParameters.IsPositional">
            <summary>Indicates whether the template should be interpreted as positional
            (all holes are numbers) or named.</summary>
        </member>
        <member name="P:NLog.MessageTemplates.MessageTemplateParameters.IsValidTemplate">
            <summary>
            Indicates whether the template was parsed successful, and there are no unmatched parameters
            </summary>
        </member>
        <member name="M:NLog.MessageTemplates.MessageTemplateParameters.#ctor(System.String,System.Object[])">
            <summary>
            Constructor for parsing the message template with parameters
            </summary>
            <param name="message"><see cref="P:NLog.LogEventInfo.Message"/> including any parameter placeholders</param>
            <param name="parameters">All <see cref="P:NLog.LogEventInfo.Parameters"/></param>
        </member>
        <member name="M:NLog.MessageTemplates.MessageTemplateParameters.#ctor(System.Collections.Generic.IList{NLog.MessageTemplates.MessageTemplateParameter},System.String,System.Object[])">
            <summary>
            Constructor for named parameters that already has been parsed
            </summary>
        </member>
        <member name="M:NLog.MessageTemplates.MessageTemplateParameters.ParseMessageTemplate(System.String,System.Object[],System.Boolean@,System.Boolean@)">
            <summary>
            Create MessageTemplateParameter from <paramref name="parameters"/>
            </summary>
        </member>
        <member name="T:NLog.MessageTemplates.TemplateEnumerator">
            <summary>
            Parse templates.
            </summary>
        </member>
        <member name="M:NLog.MessageTemplates.TemplateEnumerator.#ctor(System.String)">
            <summary>
            Parse a template.
            </summary>
            <param name="template">Template to be parsed.</param>
            <exception cref="T:System.ArgumentNullException">When <paramref name="template"/> is null.</exception>
            <returns>Template, never null</returns>
        </member>
        <member name="P:NLog.MessageTemplates.TemplateEnumerator.Current">
            <summary>
            Gets the current literal/hole in the template
            </summary>
        </member>
        <member name="M:NLog.MessageTemplates.TemplateEnumerator.Dispose">
            <summary>
            Clears the enumerator
            </summary>
        </member>
        <member name="M:NLog.MessageTemplates.TemplateEnumerator.Reset">
            <summary>
            Restarts the enumerator of the template
            </summary>
        </member>
        <member name="M:NLog.MessageTemplates.TemplateEnumerator.MoveNext">
            <summary>
            Moves to the next literal/hole in the template
            </summary>
            <returns>Found new element [true/false]</returns>
        </member>
        <member name="M:NLog.MessageTemplates.TemplateEnumerator.ParseFormat">
            <summary>
            Parse format after hole name/index. Handle the escaped { and } in the format. Don't read the last }
            </summary>
            <returns></returns>
        </member>
        <member name="T:NLog.MessageTemplates.TemplateParserException">
            <summary>
            Error when parsing a template.
            </summary>
        </member>
        <member name="P:NLog.MessageTemplates.TemplateParserException.Index">
            <summary>
            Current index when the error occurred.
            </summary>
        </member>
        <member name="P:NLog.MessageTemplates.TemplateParserException.Template">
            <summary>
            The template we were parsing
            </summary>
        </member>
        <member name="M:NLog.MessageTemplates.TemplateParserException.#ctor(System.String,System.Int32,System.String)">
            <summary>
            New exception
            </summary>
            <param name="message">The message to be shown.</param>
            <param name="index">Current index when the error occurred.</param>
            <param name="template"></param>
        </member>
        <member name="T:NLog.MessageTemplates.ValueFormatter">
            <summary>
            Convert, Render or serialize a value, with optionally backwards-compatible with <see cref="M:System.String.Format(System.IFormatProvider,System.String,System.Object[])"/>
            </summary>
        </member>
        <member name="M:NLog.MessageTemplates.ValueFormatter.FormatValue(System.Object,System.String,NLog.MessageTemplates.CaptureType,System.IFormatProvider,System.Text.StringBuilder)">
            <summary>
            Serialization of an object, e.g. JSON and append to <paramref name="builder"/>
            </summary>
            <param name="value">The object to serialize to string.</param>
            <param name="format">Parameter Format</param>
            <param name="captureType">Parameter CaptureType</param>
            <param name="formatProvider">An object that supplies culture-specific formatting information.</param>
            <param name="builder">Output destination.</param>
            <returns>Serialize succeeded (true/false)</returns>
        </member>
        <member name="M:NLog.MessageTemplates.ValueFormatter.FormatObject(System.Object,System.String,System.IFormatProvider,System.Text.StringBuilder)">
            <summary>
            Format an object to a readable string, or if it's an object, serialize
            </summary>
            <param name="value">The value to convert</param>
            <param name="format"></param>
            <param name="formatProvider"></param>
            <param name="builder"></param>
            <returns></returns>
        </member>
        <member name="M:NLog.MessageTemplates.ValueFormatter.SerializeSimpleObject(System.Object,System.String,System.IFormatProvider,System.Text.StringBuilder,System.Boolean)">
            <summary>
            Try serializing a scalar (string, int, NULL) or simple type (IFormattable)
            </summary>
        </member>
        <member name="M:NLog.MessageTemplates.ValueFormatter.SerializeDictionaryObject(System.Collections.IDictionary,System.String,System.IFormatProvider,System.Text.StringBuilder,NLog.Internal.SingleItemOptimizedHashSet{System.Object},System.Int32)">
            <summary>
            Serialize Dictionary as JSON like structure, without { and }
            </summary>
            <example>
            "FirstOrder"=true, "Previous login"=20-12-2017 14:55:32, "number of tries"=1
            </example>
            <param name="dictionary"></param>
            <param name="format">format string of an item</param>
            <param name="formatProvider"></param>
            <param name="builder"></param>
            <param name="objectsInPath"></param>
            <param name="depth"></param>
            <returns></returns>
        </member>
        <member name="M:NLog.MessageTemplates.ValueFormatter.FormatToString(System.Object,System.String,System.IFormatProvider,System.Text.StringBuilder)">
            <summary>
            Convert a value to a string with format and append to <paramref name="builder"/>.
            </summary>
            <param name="value">The value to convert.</param>
            <param name="format">Format sting for the value.</param>
            <param name="formatProvider">Format provider for the value.</param>
            <param name="builder">Append to this</param>
        </member>
        <member name="T:NLog.NestedDiagnosticsContext">
             <summary>
             Obsolete and replaced by <see cref="T:NLog.ScopeContext"/> with NLog v5.
            
             Nested Diagnostics Context (NDC) is a stack of nested values.
             Stores the stack in the thread-local static variable, and provides methods to output the values in layouts.
             </summary>
        </member>
        <member name="P:NLog.NestedDiagnosticsContext.TopMessage">
            <summary>
            Gets the top NDC message but doesn't remove it.
            </summary>
            <returns>The top message. .</returns>
        </member>
        <member name="P:NLog.NestedDiagnosticsContext.TopObject">
            <summary>
            Gets the top NDC object but doesn't remove it.
            </summary>
            <returns>The object at the top of the NDC stack if defined; otherwise <c>null</c>.</returns>
        </member>
        <member name="M:NLog.NestedDiagnosticsContext.Push(System.String)">
            <summary>
            Pushes the specified text on current thread NDC.
            </summary>
            <param name="text">The text to be pushed.</param>
            <returns>An instance of the object that implements IDisposable that returns the stack to the previous level when IDisposable.Dispose() is called. To be used with C# using() statement.</returns>
        </member>
        <member name="M:NLog.NestedDiagnosticsContext.Push(System.Object)">
            <summary>
            Pushes the specified object on current thread NDC.
            </summary>
            <param name="value">The object to be pushed.</param>
            <returns>An instance of the object that implements IDisposable that returns the stack to the previous level when IDisposable.Dispose() is called. To be used with C# using() statement.</returns>
        </member>
        <member name="M:NLog.NestedDiagnosticsContext.Pop">
            <summary>
            Pops the top message off the NDC stack.
            </summary>
            <returns>The top message which is no longer on the stack.</returns>
        </member>
        <member name="M:NLog.NestedDiagnosticsContext.Pop(System.IFormatProvider)">
            <summary>
            Pops the top message from the NDC stack.
            </summary>
            <param name="formatProvider">The <see cref="T:System.IFormatProvider"/> to use when converting the value to a string.</param>
            <returns>The top message, which is removed from the stack, as a string value.</returns>
        </member>
        <member name="M:NLog.NestedDiagnosticsContext.PopObject">
            <summary>
            Pops the top object off the NDC stack.
            </summary>
            <returns>The object from the top of the NDC stack, if defined; otherwise <c>null</c>.</returns>
        </member>
        <member name="M:NLog.NestedDiagnosticsContext.PeekObject">
            <summary>
            Peeks the first object on the NDC stack
            </summary>
            <returns>The object from the top of the NDC stack, if defined; otherwise <c>null</c>.</returns>
        </member>
        <member name="M:NLog.NestedDiagnosticsContext.Clear">
            <summary>
            Clears current thread NDC stack.
            </summary>
        </member>
        <member name="M:NLog.NestedDiagnosticsContext.GetAllMessages">
            <summary>
            Gets all messages on the stack.
            </summary>
            <returns>Array of strings on the stack.</returns>
        </member>
        <member name="M:NLog.NestedDiagnosticsContext.GetAllMessages(System.IFormatProvider)">
            <summary>
            Gets all messages from the stack, without removing them.
            </summary>
            <param name="formatProvider">The <see cref="T:System.IFormatProvider"/> to use when converting a value to a string.</param>
            <returns>Array of strings.</returns>
        </member>
        <member name="M:NLog.NestedDiagnosticsContext.GetAllObjects">
            <summary>
            Gets all objects on the stack.
            </summary>
            <returns>Array of objects on the stack.</returns>
        </member>
        <member name="T:NLog.NestedDiagnosticsLogicalContext">
             <summary>
             Obsolete and replaced by <see cref="T:NLog.ScopeContext"/> with NLog v5.
            
             Nested Diagnostics Logical Context (NDLC) is a stack of nested values.
             Stores the stack in the logical thread callcontexte, and provides methods to output the values in layouts.
             </summary>
        </member>
        <member name="M:NLog.NestedDiagnosticsLogicalContext.Push``1(``0)">
            <summary>
            Pushes the specified value on current stack
            </summary>
            <param name="value">The value to be pushed.</param>
            <returns>An instance of the object that implements IDisposable that returns the stack to the previous level when IDisposable.Dispose() is called. To be used with C# using() statement.</returns>
        </member>
        <member name="M:NLog.NestedDiagnosticsLogicalContext.PushObject(System.Object)">
            <summary>
            Pushes the specified value on current stack
            </summary>
            <param name="value">The value to be pushed.</param>
            <returns>An instance of the object that implements IDisposable that returns the stack to the previous level when IDisposable.Dispose() is called. To be used with C# using() statement.</returns>
        </member>
        <member name="M:NLog.NestedDiagnosticsLogicalContext.Pop">
            <summary>
            Pops the top message off the NDLC stack.
            </summary>
            <returns>The top message which is no longer on the stack.</returns>
            <remarks>this methods returns a object instead of string, this because of backwards-compatibility</remarks>
        </member>
        <member name="M:NLog.NestedDiagnosticsLogicalContext.Pop(System.IFormatProvider)">
            <summary>
            Pops the top message from the NDLC stack.
            </summary>
            <param name="formatProvider">The <see cref="T:System.IFormatProvider"/> to use when converting the value to a string.</param>
            <returns>The top message, which is removed from the stack, as a string value.</returns>
        </member>
        <member name="M:NLog.NestedDiagnosticsLogicalContext.PopObject">
            <summary>
            Pops the top message off the current NDLC stack
            </summary>
            <returns>The object from the top of the NDLC stack, if defined; otherwise <c>null</c>.</returns>
        </member>
        <member name="M:NLog.NestedDiagnosticsLogicalContext.PeekObject">
            <summary>
            Peeks the top object on the current NDLC stack
            </summary>
            <returns>The object from the top of the NDLC stack, if defined; otherwise <c>null</c>.</returns>
        </member>
        <member name="M:NLog.NestedDiagnosticsLogicalContext.Clear">
            <summary>
            Clears current stack.
            </summary>
        </member>
        <member name="M:NLog.NestedDiagnosticsLogicalContext.GetAllMessages">
            <summary>
            Gets all messages on the stack.
            </summary>
            <returns>Array of strings on the stack.</returns>
        </member>
        <member name="M:NLog.NestedDiagnosticsLogicalContext.GetAllMessages(System.IFormatProvider)">
            <summary>
            Gets all messages from the stack, without removing them.
            </summary>
            <param name="formatProvider">The <see cref="T:System.IFormatProvider"/> to use when converting a value to a string.</param>
            <returns>Array of strings.</returns>
        </member>
        <member name="M:NLog.NestedDiagnosticsLogicalContext.GetAllObjects">
            <summary>
            Gets all objects on the stack. The objects are not removed from the stack.
            </summary>
            <returns>Array of objects on the stack.</returns>
        </member>
        <member name="T:NLog.NLogConfigurationException">
            <summary>
            Exception thrown during NLog configuration.
            </summary>
        </member>
        <member name="M:NLog.NLogConfigurationException.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.NLogConfigurationException" /> class.
            </summary>
        </member>
        <member name="M:NLog.NLogConfigurationException.#ctor(System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.NLogConfigurationException" /> class.
            </summary>
            <param name="message">The message.</param>
        </member>
        <member name="M:NLog.NLogConfigurationException.#ctor(System.String,System.Object[])">
            <summary>
            Obsolete and replaced by using normal string-interpolation with <see cref="M:NLog.NLogConfigurationException.#ctor(System.String)"/> in NLog v5.
            Initializes a new instance of the <see cref="T:NLog.NLogConfigurationException" /> class.
            </summary>
            <param name="message">The message.</param>
            <param name="messageParameters">Parameters for the message</param>
        </member>
        <member name="M:NLog.NLogConfigurationException.#ctor(System.Exception,System.String,System.Object[])">
            <summary>
            Obsolete and replaced by using normal string-interpolation with <see cref="M:NLog.NLogConfigurationException.#ctor(System.String)"/> in NLog v5.
            Initializes a new instance of the <see cref="T:NLog.NLogConfigurationException" /> class.
            </summary>
            <param name="innerException">The inner exception.</param>
            <param name="message">The message.</param>
            <param name="messageParameters">Parameters for the message</param>
        </member>
        <member name="M:NLog.NLogConfigurationException.#ctor(System.String,System.Exception)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.NLogConfigurationException" /> class.
            </summary>
            <param name="message">The message.</param>
            <param name="innerException">The inner exception.</param>
        </member>
        <member name="M:NLog.NLogConfigurationException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.NLogConfigurationException" /> class.
            </summary>
            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param>
            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
            <exception cref="T:System.ArgumentNullException">
            The <paramref name="info"/> parameter is null.
            </exception>
            <exception cref="T:System.Runtime.Serialization.SerializationException">
            The class name is null or <see cref="P:System.Exception.HResult"/> is zero (0).
            </exception>
        </member>
        <member name="T:NLog.NLogRuntimeException">
            <summary>
            Exception thrown during log event processing.
            </summary>
        </member>
        <member name="M:NLog.NLogRuntimeException.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.NLogRuntimeException" /> class.
            </summary>
        </member>
        <member name="M:NLog.NLogRuntimeException.#ctor(System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.NLogRuntimeException" /> class.
            </summary>
            <param name="message">The message.</param>
        </member>
        <member name="M:NLog.NLogRuntimeException.#ctor(System.String,System.Object[])">
            <summary>
            Obsolete and replaced by using normal string-interpolation with <see cref="M:NLog.NLogRuntimeException.#ctor(System.String)"/> in NLog v5.
            Initializes a new instance of the <see cref="T:NLog.NLogRuntimeException" /> class.
            </summary>
            <param name="message">The message.</param>
            <param name="messageParameters">Parameters for the message</param>
        </member>
        <member name="M:NLog.NLogRuntimeException.#ctor(System.String,System.Exception)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.NLogRuntimeException" /> class.
            </summary>
            <param name="message">The message.</param>
            <param name="innerException">The inner exception.</param>
        </member>
        <member name="M:NLog.NLogRuntimeException.#ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.NLogRuntimeException" /> class.
            </summary>
            <param name="info">The <see cref="T:System.Runtime.Serialization.SerializationInfo"/> that holds the serialized object data about the exception being thrown.</param>
            <param name="context">The <see cref="T:System.Runtime.Serialization.StreamingContext"/> that contains contextual information about the source or destination.</param>
            <exception cref="T:System.ArgumentNullException">
            The <paramref name="info"/> parameter is null.
            </exception>
            <exception cref="T:System.Runtime.Serialization.SerializationException">
            The class name is null or <see cref="P:System.Exception.HResult"/> is zero (0).
            </exception>
        </member>
        <member name="T:NLog.NLogTraceListener">
            <summary>
            TraceListener which routes all messages through NLog.
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/NLog-Trace-Listener-for-System-Diagnostics-Trace">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/NLog-Trace-Listener-for-System-Diagnostics-Trace">Documentation on NLog Wiki</seealso>
        </member>
        <member name="M:NLog.NLogTraceListener.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.NLogTraceListener"/> class.
            </summary>
        </member>
        <member name="P:NLog.NLogTraceListener.LogFactory">
            <summary>
            Gets or sets the log factory to use when outputting messages (null - use LogManager).
            </summary>
        </member>
        <member name="P:NLog.NLogTraceListener.DefaultLogLevel">
            <summary>
            Gets or sets the default log level.
            </summary>
        </member>
        <member name="P:NLog.NLogTraceListener.ForceLogLevel">
            <summary>
            Gets or sets the log which should be always used regardless of source level.
            </summary>
        </member>
        <member name="P:NLog.NLogTraceListener.DisableFlush">
            <summary>
            Gets or sets a value indicating whether flush calls from trace sources should be ignored.
            </summary>
        </member>
        <member name="P:NLog.NLogTraceListener.IsThreadSafe">
            <summary>
            Gets a value indicating whether the trace listener is thread safe.
            </summary>
            <value></value>
            <returns>true if the trace listener is thread safe; otherwise, false. The default is false.</returns>
        </member>
        <member name="P:NLog.NLogTraceListener.AutoLoggerName">
            <summary>
            Gets or sets a value indicating whether to use auto logger name detected from the stack trace.
            </summary>
            <remarks>Default Logger-Name is <see cref="P:System.Diagnostics.TraceListener.Name"/> of the <see cref="T:NLog.NLogTraceListener" /></remarks>
        </member>
        <member name="M:NLog.NLogTraceListener.Write(System.String)">
            <summary>
            When overridden in a derived class, writes the specified message to the listener you create in the derived class.
            </summary>
            <param name="message">A message to write.</param>
        </member>
        <member name="M:NLog.NLogTraceListener.Write(System.Object)">
            <summary>
            When overridden in a derived class, writes the specified message to the listener you create in the derived class.
            </summary>
            <param name="o">A message payload to write.</param>
        </member>
        <member name="M:NLog.NLogTraceListener.WriteLine(System.String)">
            <summary>
            When overridden in a derived class, writes a message to the listener you create in the derived class, followed by a line terminator.
            </summary>
            <param name="message">A message to write.</param>
        </member>
        <member name="M:NLog.NLogTraceListener.WriteLine(System.Object)">
            <summary>
            When overridden in a derived class, writes the specified message to the listener you create in the derived class.
            </summary>
            <param name="o">A message payload to write.</param>
        </member>
        <member name="M:NLog.NLogTraceListener.Close">
            <summary>
            When overridden in a derived class, closes the output stream so it no longer receives tracing or debugging output.
            </summary>
        </member>
        <member name="M:NLog.NLogTraceListener.Fail(System.String)">
            <summary>
            Emits an error message.
            </summary>
            <param name="message">A message to emit.</param>
        </member>
        <member name="M:NLog.NLogTraceListener.Fail(System.String,System.String)">
            <summary>
            Emits an error message and a detailed error message.
            </summary>
            <param name="message">A message to emit.</param>
            <param name="detailMessage">A detailed message to emit.</param>
        </member>
        <member name="M:NLog.NLogTraceListener.Flush">
            <summary>
            Flushes the output (if <see cref="P:NLog.NLogTraceListener.DisableFlush"/> is not <c>true</c>) buffer with the default timeout of 15 seconds.
            </summary>
        </member>
        <member name="M:NLog.NLogTraceListener.TraceData(System.Diagnostics.TraceEventCache,System.String,System.Diagnostics.TraceEventType,System.Int32,System.Object)">
            <summary>
            Writes trace information, a data object and event information to the listener specific output.
            </summary>
            <param name="eventCache">A <see cref="T:System.Diagnostics.TraceEventCache"/> object that contains the current process ID, thread ID, and stack trace information.</param>
            <param name="source">A name used to identify the output, typically the name of the application that generated the trace event.</param>
            <param name="eventType">One of the <see cref="T:System.Diagnostics.TraceEventType"/> values specifying the type of event that has caused the trace.</param>
            <param name="id">A numeric identifier for the event.</param>
            <param name="data">The trace data to emit.</param>
        </member>
        <member name="M:NLog.NLogTraceListener.TraceData(System.Diagnostics.TraceEventCache,System.String,System.Diagnostics.TraceEventType,System.Int32,System.Object[])">
            <summary>
            Writes trace information, an array of data objects and event information to the listener specific output.
            </summary>
            <param name="eventCache">A <see cref="T:System.Diagnostics.TraceEventCache"/> object that contains the current process ID, thread ID, and stack trace information.</param>
            <param name="source">A name used to identify the output, typically the name of the application that generated the trace event.</param>
            <param name="eventType">One of the <see cref="T:System.Diagnostics.TraceEventType"/> values specifying the type of event that has caused the trace.</param>
            <param name="id">A numeric identifier for the event.</param>
            <param name="data">An array of objects to emit as data.</param>
        </member>
        <member name="M:NLog.NLogTraceListener.TraceEvent(System.Diagnostics.TraceEventCache,System.String,System.Diagnostics.TraceEventType,System.Int32)">
            <summary>
            Writes trace and event information to the listener specific output.
            </summary>
            <param name="eventCache">A <see cref="T:System.Diagnostics.TraceEventCache"/> object that contains the current process ID, thread ID, and stack trace information.</param>
            <param name="source">A name used to identify the output, typically the name of the application that generated the trace event.</param>
            <param name="eventType">One of the <see cref="T:System.Diagnostics.TraceEventType"/> values specifying the type of event that has caused the trace.</param>
            <param name="id">A numeric identifier for the event.</param>
        </member>
        <member name="M:NLog.NLogTraceListener.TraceEvent(System.Diagnostics.TraceEventCache,System.String,System.Diagnostics.TraceEventType,System.Int32,System.String,System.Object[])">
            <summary>
            Writes trace information, a formatted array of objects and event information to the listener specific output.
            </summary>
            <param name="eventCache">A <see cref="T:System.Diagnostics.TraceEventCache"/> object that contains the current process ID, thread ID, and stack trace information.</param>
            <param name="source">A name used to identify the output, typically the name of the application that generated the trace event.</param>
            <param name="eventType">One of the <see cref="T:System.Diagnostics.TraceEventType"/> values specifying the type of event that has caused the trace.</param>
            <param name="id">A numeric identifier for the event.</param>
            <param name="format">A format string that contains zero or more format items, which correspond to objects in the <paramref name="args"/> array.</param>
            <param name="args">An object array containing zero or more objects to format.</param>
        </member>
        <member name="M:NLog.NLogTraceListener.TraceEvent(System.Diagnostics.TraceEventCache,System.String,System.Diagnostics.TraceEventType,System.Int32,System.String)">
            <summary>
            Writes trace information, a message, and event information to the listener specific output.
            </summary>
            <param name="eventCache">A <see cref="T:System.Diagnostics.TraceEventCache"/> object that contains the current process ID, thread ID, and stack trace information.</param>
            <param name="source">A name used to identify the output, typically the name of the application that generated the trace event.</param>
            <param name="eventType">One of the <see cref="T:System.Diagnostics.TraceEventType"/> values specifying the type of event that has caused the trace.</param>
            <param name="id">A numeric identifier for the event.</param>
            <param name="message">A message to write.</param>
        </member>
        <member name="M:NLog.NLogTraceListener.TraceTransfer(System.Diagnostics.TraceEventCache,System.String,System.Int32,System.String,System.Guid)">
            <summary>
            Writes trace information, a message, a related activity identity and event information to the listener specific output.
            </summary>
            <param name="eventCache">A <see cref="T:System.Diagnostics.TraceEventCache"/> object that contains the current process ID, thread ID, and stack trace information.</param>
            <param name="source">A name used to identify the output, typically the name of the application that generated the trace event.</param>
            <param name="id">A numeric identifier for the event.</param>
            <param name="message">A message to write.</param>
            <param name="relatedActivityId">A <see cref="T:System.Guid"/>  object identifying a related activity.</param>
        </member>
        <member name="M:NLog.NLogTraceListener.GetSupportedAttributes">
            <summary>
            Gets the custom attributes supported by the trace listener.
            </summary>
            <returns>
            A string array naming the custom attributes supported by the trace listener, or null if there are no custom attributes.
            </returns>
        </member>
        <member name="M:NLog.NLogTraceListener.TranslateLogLevel(System.Diagnostics.TraceEventType)">
            <summary>
            Translates the event type to level from <see cref="T:System.Diagnostics.TraceEventType"/>.
            </summary>
            <param name="eventType">Type of the event.</param>
            <returns>Translated log level.</returns>
        </member>
        <member name="M:NLog.NLogTraceListener.ProcessLogEventInfo(NLog.LogLevel,System.String,System.String,System.Object[],System.Nullable{System.Int32},System.Nullable{System.Diagnostics.TraceEventType},System.Nullable{System.Guid})">
            <summary>
            Process the log event
            <param name="logLevel">The log level.</param>
            <param name="loggerName">The name of the logger.</param>
            <param name="message">The log message.</param>
            <param name="arguments">The log parameters.</param>
            <param name="eventId">The event id.</param>
            <param name="eventType">The event type.</param>
            <param name="relatedActivityId">The related activity id.</param>
            </summary>
        </member>
        <member name="T:NLog.NullLogger">
             <summary>
             It works as a normal <see cref="T:NLog.Logger" /> but it discards all messages which an application requests
             to be logged.
            
             It effectively implements the "Null Object" pattern for <see cref="T:NLog.Logger" /> objects.
             </summary>
        </member>
        <member name="M:NLog.NullLogger.#ctor(NLog.LogFactory)">
            <summary>
            Initializes a new instance of <see cref="T:NLog.NullLogger"/>.
            </summary>
            <param name="factory">The factory class to be used for the creation of this logger.</param>
        </member>
        <member name="T:NLog.ScopeContext">
             <summary>
             <see cref="T:NLog.ScopeContext"/> stores state in the async thread execution context. All LogEvents created
             within a scope can include the scope state in the target output. The logical context scope supports
             both scope-properties and scope-nested-state-stack (Similar to log4j2 ThreadContext)
             </summary>
             <remarks>
             <see cref="T:NLog.MappedDiagnosticsLogicalContext"/> (MDLC), <see cref="T:NLog.MappedDiagnosticsContext"/> (MDC), <see cref="T:NLog.NestedDiagnosticsLogicalContext"/> (NDLC)
             and <see cref="T:NLog.NestedDiagnosticsContext"/> (NDC) have been deprecated and replaced by <see cref="T:NLog.ScopeContext"/>.
            
             .NetCore (and .Net46) uses AsyncLocal for handling the thread execution context. Older .NetFramework uses System.Runtime.Remoting.CallContext
             </remarks>
        </member>
        <member name="M:NLog.ScopeContext.PushNestedStateProperties(System.Object,System.Collections.Generic.IReadOnlyCollection{System.Collections.Generic.KeyValuePair{System.String,System.Object}})">
            <summary>
            Pushes new state on the logical context scope stack together with provided properties
            </summary>
            <param name="nestedState">Value to added to the scope stack</param>
            <param name="properties">Properties being added to the scope dictionary</param>
            <returns>A disposable object that pops the nested scope state on dispose (including properties).</returns>
            <remarks>Scope dictionary keys are case-insensitive</remarks>
        </member>
        <member name="M:NLog.ScopeContext.PushProperties(System.Collections.Generic.IReadOnlyCollection{System.Collections.Generic.KeyValuePair{System.String,System.Object}})">
            <summary>
            Updates the logical scope context with provided properties
            </summary>
            <param name="properties">Properties being added to the scope dictionary</param>
            <returns>A disposable object that removes the properties from logical context scope on dispose.</returns>
            <remarks>Scope dictionary keys are case-insensitive</remarks>
        </member>
        <member name="M:NLog.ScopeContext.PushProperties``1(System.Collections.Generic.IReadOnlyCollection{System.Collections.Generic.KeyValuePair{System.String,``0}})">
            <summary>
            Updates the logical scope context with provided properties
            </summary>
            <param name="properties">Properties being added to the scope dictionary</param>
            <returns>A disposable object that removes the properties from logical context scope on dispose.</returns>
            <remarks>Scope dictionary keys are case-insensitive</remarks>
        </member>
        <member name="M:NLog.ScopeContext.PushProperty``1(System.String,``0)">
            <summary>
            Updates the logical scope context with provided property
            </summary>
            <param name="key">Name of property</param>
            <param name="value">Value of property</param>
            <returns>A disposable object that removes the properties from logical context scope on dispose.</returns>
            <remarks>Scope dictionary keys are case-insensitive</remarks>
        </member>
        <member name="M:NLog.ScopeContext.PushProperty(System.String,System.Object)">
            <summary>
            Updates the logical scope context with provided property
            </summary>
            <param name="key">Name of property</param>
            <param name="value">Value of property</param>
            <returns>A disposable object that removes the properties from logical context scope on dispose.</returns>
            <remarks>Scope dictionary keys are case-insensitive</remarks>
        </member>
        <member name="M:NLog.ScopeContext.PushNestedState``1(``0)">
            <summary>
            Pushes new state on the logical context scope stack
            </summary>
            <param name="nestedState">Value to added to the scope stack</param>
            <returns>A disposable object that pops the nested scope state on dispose.</returns>
            <remarks>Skips casting of <paramref name="nestedState"/> to check for scope-properties</remarks>
        </member>
        <member name="M:NLog.ScopeContext.PushNestedState(System.Object)">
            <summary>
            Pushes new state on the logical context scope stack
            </summary>
            <param name="nestedState">Value to added to the scope stack</param>
            <returns>A disposable object that pops the nested scope state on dispose.</returns>
        </member>
        <member name="M:NLog.ScopeContext.Clear">
            <summary>
            Clears all the entire logical context scope, and removes any properties and nested-states
            </summary>
        </member>
        <member name="M:NLog.ScopeContext.GetAllProperties">
            <summary>
            Retrieves all properties stored within the logical context scopes
            </summary>
            <returns>Collection of all properties</returns>
        </member>
        <member name="M:NLog.ScopeContext.TryGetProperty(System.String,System.Object@)">
            <summary>
            Lookup single property stored within the logical context scopes
            </summary>
            <param name="key">Name of property</param>
            <param name="value">When this method returns, contains the value associated with the specified key</param>
            <returns>Returns true when value is found with the specified key</returns>
            <remarks>Scope dictionary keys are case-insensitive</remarks>
        </member>
        <member name="M:NLog.ScopeContext.GetAllNestedStates">
            <summary>
            Retrieves all nested states inside the logical context scope stack
            </summary>
            <returns>Array of nested state objects.</returns>
        </member>
        <member name="M:NLog.ScopeContext.PeekNestedState">
            <summary>
            Peeks the top value from the logical context scope stack
            </summary>
            <returns>Value from the top of the stack.</returns>
        </member>
        <member name="M:NLog.ScopeContext.PeekInnerNestedDuration">
            <summary>
            Peeks the inner state (newest) from the logical context scope stack, and returns its running duration
            </summary>
            <returns>Scope Duration Time</returns>
        </member>
        <member name="M:NLog.ScopeContext.PeekOuterNestedDuration">
            <summary>
            Peeks the outer state (oldest) from the logical context scope stack, and returns its running duration
            </summary>
            <returns>Scope Duration Time</returns>
        </member>
        <member name="T:NLog.ScopeContext.ScopeContextPropertiesCollapsed">
            <summary>
            Special bookmark that can restore original parent, after scopes has been collapsed
            </summary>
        </member>
        <member name="T:NLog.SetupBuilderExtensions">
            <summary>
            Extension methods to setup LogFactory options
            </summary>
        </member>
        <member name="M:NLog.SetupBuilderExtensions.GetCurrentClassLogger(NLog.Config.ISetupBuilder)">
            <summary>
            Gets the logger with the full name of the current class, so namespace and class name.
            </summary>
        </member>
        <member name="M:NLog.SetupBuilderExtensions.GetLogger(NLog.Config.ISetupBuilder,System.String)">
            <summary>
            Gets the specified named logger.
            </summary>
        </member>
        <member name="M:NLog.SetupBuilderExtensions.SetupLogFactory(NLog.Config.ISetupBuilder,System.Action{NLog.Config.ISetupLogFactoryBuilder})">
            <summary>
            Configures general options for NLog LogFactory before loading NLog config
            </summary>
        </member>
        <member name="M:NLog.SetupBuilderExtensions.SetupExtensions(NLog.Config.ISetupBuilder,System.Action{NLog.Config.ISetupExtensionsBuilder})">
            <summary>
            Configures loading of NLog extensions for Targets and LayoutRenderers
            </summary>
        </member>
        <member name="M:NLog.SetupBuilderExtensions.SetupInternalLogger(NLog.Config.ISetupBuilder,System.Action{NLog.Config.ISetupInternalLoggerBuilder})">
            <summary>
            Configures the output of NLog <see cref="T:NLog.Common.InternalLogger"/> for diagnostics / troubleshooting
            </summary>
        </member>
        <member name="M:NLog.SetupBuilderExtensions.SetupSerialization(NLog.Config.ISetupBuilder,System.Action{NLog.Config.ISetupSerializationBuilder})">
            <summary>
            Configures serialization and transformation of LogEvents
            </summary>
        </member>
        <member name="M:NLog.SetupBuilderExtensions.LoadConfiguration(NLog.Config.ISetupBuilder,System.Action{NLog.Config.ISetupLoadConfigurationBuilder})">
            <summary>
            Loads NLog config created by the method <paramref name="configBuilder"/>
            </summary>
        </member>
        <member name="M:NLog.SetupBuilderExtensions.LoadConfiguration(NLog.Config.ISetupBuilder,NLog.Config.LoggingConfiguration)">
            <summary>
            Loads NLog config provided in <paramref name="loggingConfiguration"/>
            </summary>
        </member>
        <member name="M:NLog.SetupBuilderExtensions.LoadConfigurationFromFile(NLog.Config.ISetupBuilder,System.String,System.Boolean)">
            <summary>
            Loads NLog config from filename <paramref name="configFile"/> if provided, else fallback to scanning for NLog.config
            </summary>
            <param name="setupBuilder">Fluent interface parameter.</param>
            <param name="configFile">Explicit configuration file to be read (Default NLog.config from candidates paths)</param>
            <param name="optional">Whether to allow application to run when NLog config is not available</param>
        </member>
        <member name="M:NLog.SetupBuilderExtensions.LoadConfigurationFromFile(NLog.Config.ISetupBuilder,System.Collections.Generic.IEnumerable{System.String},System.Boolean)">
            <summary>
            Loads NLog config from file-paths <paramref name="candidateFilePaths"/> if provided, else fallback to scanning for NLog.config
            </summary>
            <param name="setupBuilder">Fluent interface parameter.</param>
            <param name="candidateFilePaths">Candidates file paths (including filename) where to scan for NLog config files</param>
            <param name="optional">Whether to allow application to run when NLog config is not available</param>
        </member>
        <member name="M:NLog.SetupBuilderExtensions.LoadConfigurationFromXml(NLog.Config.ISetupBuilder,System.String)">
            <summary>
            Loads NLog config from XML in <paramref name="configXml"/>
            </summary>
        </member>
        <member name="M:NLog.SetupBuilderExtensions.LoadConfigurationFromAssemblyResource(NLog.Config.ISetupBuilder,System.Reflection.Assembly,System.String)">
            <summary>
            Loads NLog config located in embedded resource from main application assembly.
            </summary>
            <param name="setupBuilder">Fluent interface parameter.</param>
            <param name="applicationAssembly">Assembly for the main Application project with embedded resource</param>
            <param name="resourceName">Name of the manifest resource for NLog config XML</param>
        </member>
        <member name="M:NLog.SetupBuilderExtensions.ReloadConfiguration(NLog.Config.ISetupBuilder)">
            <summary>
            Reloads the current logging configuration and activates it
            </summary>
            <remarks>Logevents produced during the configuration-reload can become lost, as targets are unavailable while closing and initializing.</remarks>
        </member>
        <member name="T:NLog.SetupExtensionsBuilderExtensions">
            <summary>
            Extension methods to setup NLog extensions, so they are known when loading NLog LoggingConfiguration
            </summary>
        </member>
        <member name="M:NLog.SetupExtensionsBuilderExtensions.AutoLoadAssemblies(NLog.Config.ISetupExtensionsBuilder,System.Boolean)">
            <summary>
            Enable/disables autoloading of NLog extensions by scanning and loading available assemblies
            </summary>
            <remarks>
            Disabled by default as it can give a huge performance hit during startup. Recommended to keep it disabled especially when running in the cloud.
            </remarks>
        </member>
        <member name="M:NLog.SetupExtensionsBuilderExtensions.AutoLoadExtensions(NLog.Config.ISetupExtensionsBuilder)">
            <summary>
            Enable/disables autoloading of NLog extensions by scanning and loading available assemblies
            </summary>
            <remarks>
            Disabled by default as it can give a huge performance hit during startup. Recommended to keep it disabled especially when running in the cloud.
            </remarks>
        </member>
        <member name="M:NLog.SetupExtensionsBuilderExtensions.RegisterAssembly(NLog.Config.ISetupExtensionsBuilder,System.Reflection.Assembly)">
            <summary>
            Registers NLog extensions from the assembly.
            </summary>
        </member>
        <member name="M:NLog.SetupExtensionsBuilderExtensions.RegisterAssembly(NLog.Config.ISetupExtensionsBuilder,System.String)">
            <summary>
            Registers NLog extensions from the assembly type name
            </summary>
        </member>
        <member name="M:NLog.SetupExtensionsBuilderExtensions.RegisterType``1(NLog.Config.ISetupExtensionsBuilder)">
            <summary>
            Register a custom NLog Configuration Type.
            </summary>
            <typeparam name="T">Type of the NLog configuration item</typeparam>
            <param name="setupBuilder">Fluent interface parameter.</param>
        </member>
        <member name="M:NLog.SetupExtensionsBuilderExtensions.RegisterTarget``1(NLog.Config.ISetupExtensionsBuilder,System.String)">
            <summary>
            Register a custom NLog Target.
            </summary>
            <typeparam name="T">Type of the Target.</typeparam>
            <param name="setupBuilder">Fluent interface parameter.</param>
            <param name="name">The target type-alias for use in NLog configuration. Will extract from class-attribute when unassigned.</param>
        </member>
        <member name="M:NLog.SetupExtensionsBuilderExtensions.RegisterTarget``1(NLog.Config.ISetupExtensionsBuilder,System.Func{``0},System.String)">
            <summary>
            Register a custom NLog Target.
            </summary>
            <typeparam name="T">Type of the Target.</typeparam>
            <param name="setupBuilder">Fluent interface parameter.</param>
            <param name="factory">The factory method for creating instance of NLog Target</param>
            <param name="typeAlias">The target type-alias for use in NLog configuration. Will extract from class-attribute when unassigned.</param>
        </member>
        <member name="M:NLog.SetupExtensionsBuilderExtensions.RegisterTarget(NLog.Config.ISetupExtensionsBuilder,System.String,System.Type)">
            <summary>
            Register a custom NLog Target.
            </summary>
            <param name="setupBuilder">Fluent interface parameter.</param>
            <param name="name">Type name of the Target</param>
            <param name="targetType">The target type-alias for use in NLog configuration</param>
        </member>
        <member name="M:NLog.SetupExtensionsBuilderExtensions.RegisterLayout``1(NLog.Config.ISetupExtensionsBuilder,System.String)">
            <summary>
            Register a custom NLog Layout.
            </summary>
            <typeparam name="T">Type of the layout renderer.</typeparam>
            <param name="setupBuilder">Fluent interface parameter.</param>
            <param name="typeAlias">The layout type-alias for use in NLog configuration. Will extract from class-attribute when unassigned.</param>
        </member>
        <member name="M:NLog.SetupExtensionsBuilderExtensions.RegisterLayout``1(NLog.Config.ISetupExtensionsBuilder,System.Func{``0},System.String)">
            <summary>
            Register a custom NLog Layout.
            </summary>
            <typeparam name="T">Type of the layout renderer.</typeparam>
            <param name="setupBuilder">Fluent interface parameter.</param>
            <param name="factory">The factory method for creating instance of NLog Layout</param>
            <param name="typeAlias">The layout type-alias for use in NLog configuration. Will extract from class-attribute when unassigned.</param>
        </member>
        <member name="M:NLog.SetupExtensionsBuilderExtensions.RegisterLayout(NLog.Config.ISetupExtensionsBuilder,System.String,System.Type)">
            <summary>
            Register a custom NLog Layout.
            </summary>
            <param name="setupBuilder">Fluent interface parameter.</param>
            <param name="layoutType">Type of the layout.</param>
            <param name="typeAlias">The layout type-alias for use in NLog configuration</param>
        </member>
        <member name="M:NLog.SetupExtensionsBuilderExtensions.RegisterLayoutRenderer``1(NLog.Config.ISetupExtensionsBuilder,System.String)">
            <summary>
            Register a custom NLog LayoutRenderer.
            </summary>
            <typeparam name="T">Type of the layout renderer.</typeparam>
            <param name="setupBuilder">Fluent interface parameter.</param>
            <param name="name">The layout-renderer type-alias for use in NLog configuration - without '${ }'. Will extract from class-attribute when unassigned.</param>
        </member>
        <member name="M:NLog.SetupExtensionsBuilderExtensions.RegisterLayoutRenderer``1(NLog.Config.ISetupExtensionsBuilder,System.Func{``0},System.String)">
            <summary>
            Register a custom NLog LayoutRenderer.
            </summary>
            <typeparam name="T">Type of the layout renderer.</typeparam>
            <param name="setupBuilder">Fluent interface parameter.</param>
            <param name="factory">The factory method for creating instance of NLog LayoutRenderer</param>
            <param name="typeAlias">The layout-renderer type-alias for use in NLog configuration - without '${ }'. Will extract from class-attribute when unassigned.</param>
        </member>
        <member name="M:NLog.SetupExtensionsBuilderExtensions.RegisterLayoutRenderer(NLog.Config.ISetupExtensionsBuilder,System.String,System.Type)">
            <summary>
            Register a custom NLog LayoutRenderer.
            </summary>
            <param name="setupBuilder">Fluent interface parameter.</param>
            <param name="layoutRendererType">Type of the layout renderer.</param>
            <param name="name">The layout-renderer type-alias for use in NLog configuration - without '${ }'</param>
        </member>
        <member name="M:NLog.SetupExtensionsBuilderExtensions.RegisterLayoutRenderer(NLog.Config.ISetupExtensionsBuilder,System.String,System.Func{NLog.LogEventInfo,System.Object})">
            <summary>
            Register a custom NLog LayoutRenderer with a callback function <paramref name="layoutMethod"/>. The callback receives the logEvent.
            </summary>
            <param name="setupBuilder">Fluent interface parameter.</param>
            <param name="name">The layout-renderer type-alias for use in NLog configuration - without '${ }'</param>
            <param name="layoutMethod">Callback that returns the value for the layout renderer.</param>
        </member>
        <member name="M:NLog.SetupExtensionsBuilderExtensions.RegisterLayoutRenderer(NLog.Config.ISetupExtensionsBuilder,System.String,System.Func{NLog.LogEventInfo,NLog.Config.LoggingConfiguration,System.Object})">
            <summary>
            Register a custom NLog LayoutRenderer with a callback function <paramref name="layoutMethod"/>. The callback receives the logEvent and the current configuration.
            </summary>
            <param name="setupBuilder">Fluent interface parameter.</param>
            <param name="name">The layout-renderer type-alias for use in NLog configuration - without '${ }'</param>
            <param name="layoutMethod">Callback that returns the value for the layout renderer.</param>
        </member>
        <member name="M:NLog.SetupExtensionsBuilderExtensions.RegisterLayoutRenderer(NLog.Config.ISetupExtensionsBuilder,System.String,System.Func{NLog.LogEventInfo,System.Object},NLog.Layouts.LayoutRenderOptions)">
            <summary>
            Register a custom NLog LayoutRenderer with a callback function <paramref name="layoutMethod"/>. The callback receives the logEvent.
            </summary>
            <param name="setupBuilder">Fluent interface parameter.</param>
            <param name="name">The layout-renderer type-alias for use in NLog configuration - without '${ }'</param>
            <param name="layoutMethod">Callback that returns the value for the layout renderer.</param>
            <param name="options">Whether method is ThreadAgnostic and doesn't depend on context of the logging application thread.</param>
        </member>
        <member name="M:NLog.SetupExtensionsBuilderExtensions.RegisterLayoutRenderer(NLog.Config.ISetupExtensionsBuilder,System.String,System.Func{NLog.LogEventInfo,NLog.Config.LoggingConfiguration,System.Object},NLog.Layouts.LayoutRenderOptions)">
            <summary>
            Register a custom NLog LayoutRenderer with a callback function <paramref name="layoutMethod"/>. The callback receives the logEvent and the current configuration.
            </summary>
            <param name="setupBuilder">Fluent interface parameter.</param>
            <param name="name">The layout-renderer type-alias for use in NLog configuration - without '${ }'</param>
            <param name="layoutMethod">Callback that returns the value for the layout renderer.</param>
            <param name="options">Whether method is ThreadAgnostic and doesn't depend on context of the logging application thread.</param>
        </member>
        <member name="M:NLog.SetupExtensionsBuilderExtensions.RegisterLayoutRenderer(NLog.Config.ISetupExtensionsBuilder,NLog.LayoutRenderers.FuncLayoutRenderer)">
            <summary>
            Register a custom NLog LayoutRenderer with a callback function
            </summary>
            <param name="setupBuilder">Fluent interface parameter.</param>
            <param name="layoutRenderer">LayoutRenderer instance with type-alias and callback-method.</param>
        </member>
        <member name="M:NLog.SetupExtensionsBuilderExtensions.RegisterConditionMethod(NLog.Config.ISetupExtensionsBuilder,System.String,System.Reflection.MethodInfo)">
            <summary>
            Register a custom condition method, that can use in condition filters
            </summary>
            <param name="setupBuilder">Fluent interface parameter.</param>
            <param name="name">Name of the condition filter method</param>
            <param name="conditionMethod">MethodInfo extracted by reflection - typeof(MyClass).GetMethod("MyFunc", BindingFlags.Static).</param>
        </member>
        <member name="M:NLog.SetupExtensionsBuilderExtensions.RegisterConditionMethod(NLog.Config.ISetupExtensionsBuilder,System.String,System.Func{NLog.LogEventInfo,System.Object})">
            <summary>
            Register a custom condition method, that can use in condition filters
            </summary>
            <param name="setupBuilder">Fluent interface parameter.</param>
            <param name="name">Name of the condition filter method</param>
            <param name="conditionMethod">Lambda method.</param>
        </member>
        <member name="M:NLog.SetupExtensionsBuilderExtensions.RegisterConditionMethod(NLog.Config.ISetupExtensionsBuilder,System.String,System.Func{System.Object})">
            <summary>
            Register a custom condition method, that can use in condition filters
            </summary>
            <param name="setupBuilder">Fluent interface parameter.</param>
            <param name="name">Name of the condition filter method</param>
            <param name="conditionMethod">Lambda method.</param>
        </member>
        <member name="M:NLog.SetupExtensionsBuilderExtensions.RegisterSingletonService``1(NLog.Config.ISetupExtensionsBuilder,``0)">
            <summary>
            Register (or replaces) singleton-object for the specified service-type
            </summary>
            <typeparam name="T">Service interface type</typeparam>
            <param name="setupBuilder">Fluent interface parameter.</param>
            <param name="singletonService">Implementation of interface.</param>
        </member>
        <member name="M:NLog.SetupExtensionsBuilderExtensions.RegisterSingletonService(NLog.Config.ISetupExtensionsBuilder,System.Type,System.Object)">
            <summary>
            Register (or replaces) singleton-object for the specified service-type
            </summary>
            <param name="setupBuilder">Fluent interface parameter.</param>
            <param name="interfaceType">Service interface type.</param>
            <param name="singletonService">Implementation of interface.</param>
        </member>
        <member name="M:NLog.SetupExtensionsBuilderExtensions.RegisterServiceProvider(NLog.Config.ISetupExtensionsBuilder,System.IServiceProvider)">
            <summary>
            Register (or replaces) external service-repository for resolving dependency injection
            </summary>
            <param name="setupBuilder">Fluent interface parameter.</param>
            <param name="serviceProvider">External dependency injection repository</param>
        </member>
        <member name="T:NLog.SetupInternalLoggerBuilderExtensions">
            <summary>
            Extension methods to setup NLog <see cref="T:NLog.Common.InternalLogger"/> options
            </summary>
        </member>
        <member name="M:NLog.SetupInternalLoggerBuilderExtensions.SetMinimumLogLevel(NLog.Config.ISetupInternalLoggerBuilder,NLog.LogLevel)">
            <summary>
            Configures <see cref="P:NLog.Common.InternalLogger.LogLevel"/>
            </summary>
        </member>
        <member name="M:NLog.SetupInternalLoggerBuilderExtensions.LogToFile(NLog.Config.ISetupInternalLoggerBuilder,System.String)">
            <summary>
            Configures <see cref="P:NLog.Common.InternalLogger.LogFile"/>
            </summary>
        </member>
        <member name="M:NLog.SetupInternalLoggerBuilderExtensions.LogToConsole(NLog.Config.ISetupInternalLoggerBuilder,System.Boolean)">
            <summary>
            Configures <see cref="P:NLog.Common.InternalLogger.LogToConsole"/>
            </summary>
        </member>
        <member name="M:NLog.SetupInternalLoggerBuilderExtensions.LogToTrace(NLog.Config.ISetupInternalLoggerBuilder,System.Boolean)">
            <summary>
            Configures <see cref="P:NLog.Common.InternalLogger.LogToTrace"/>
            </summary>
        </member>
        <member name="M:NLog.SetupInternalLoggerBuilderExtensions.LogToWriter(NLog.Config.ISetupInternalLoggerBuilder,System.IO.TextWriter)">
            <summary>
            Configures <see cref="P:NLog.Common.InternalLogger.LogWriter"/>
            </summary>
        </member>
        <member name="M:NLog.SetupInternalLoggerBuilderExtensions.AddLogSubscription(NLog.Config.ISetupInternalLoggerBuilder,System.EventHandler{NLog.Common.InternalLoggerMessageEventArgs})">
            <summary>
            Configures <see cref="E:NLog.Common.InternalLogger.LogMessageReceived"/>
            </summary>
        </member>
        <member name="M:NLog.SetupInternalLoggerBuilderExtensions.RemoveLogSubscription(NLog.Config.ISetupInternalLoggerBuilder,System.EventHandler{NLog.Common.InternalLoggerMessageEventArgs})">
            <summary>
            Configures <see cref="E:NLog.Common.InternalLogger.LogMessageReceived"/>
            </summary>
        </member>
        <member name="M:NLog.SetupInternalLoggerBuilderExtensions.AddEventSubscription(NLog.Config.ISetupInternalLoggerBuilder,NLog.Common.InternalEventOccurredHandler)">
            <summary>
            Configures <see cref="E:NLog.Common.InternalLogger.InternalEventOccurred"/>
            </summary>
        </member>
        <member name="M:NLog.SetupInternalLoggerBuilderExtensions.RemoveEventSubscription(NLog.Config.ISetupInternalLoggerBuilder,NLog.Common.InternalEventOccurredHandler)">
            <summary>
            Configures <see cref="E:NLog.Common.InternalLogger.InternalEventOccurred"/>
            </summary>
        </member>
        <member name="M:NLog.SetupInternalLoggerBuilderExtensions.ResetConfig(NLog.Config.ISetupInternalLoggerBuilder)">
            <summary>
            Resets the InternalLogger configuration without resolving default values from Environment-varialbes or App.config
            </summary>
        </member>
        <member name="M:NLog.SetupInternalLoggerBuilderExtensions.SetupFromEnvironmentVariables(NLog.Config.ISetupInternalLoggerBuilder)">
             <summary>
             Configure the InternalLogger properties from Environment-variables and App.config using <see cref="M:NLog.Common.InternalLogger.Reset"/>
             </summary>
             <remarks>
             Recognizes the following environment-variables:
            
             - NLOG_INTERNAL_LOG_LEVEL
             - NLOG_INTERNAL_LOG_FILE
             - NLOG_INTERNAL_LOG_TO_CONSOLE
             - NLOG_INTERNAL_LOG_TO_CONSOLE_ERROR
             - NLOG_INTERNAL_LOG_TO_TRACE
             - NLOG_INTERNAL_INCLUDE_TIMESTAMP
            
             Legacy .NetFramework platform will also recognizes the following app.config settings:
            
             - nlog.internalLogLevel
             - nlog.internalLogFile
             - nlog.internalLogToConsole
             - nlog.internalLogToConsoleError
             - nlog.internalLogToTrace
             - nlog.internalLogIncludeTimestamp
             </remarks>
        </member>
        <member name="T:NLog.SetupLoadConfigurationExtensions">
            <summary>
            Extension methods to setup NLog <see cref="T:NLog.Config.LoggingConfiguration"/>
            </summary>
        </member>
        <member name="M:NLog.SetupLoadConfigurationExtensions.SetTimeSource(NLog.Config.ISetupLoadConfigurationBuilder,NLog.Time.TimeSource)">
            <summary>
            Configures the global time-source used for all logevents
            </summary>
            <remarks>
            Available by default: <see cref="T:NLog.Time.AccurateLocalTimeSource"/>, <see cref="T:NLog.Time.AccurateUtcTimeSource"/>, <see cref="T:NLog.Time.FastLocalTimeSource"/>, <see cref="T:NLog.Time.FastUtcTimeSource"/>
            </remarks>
        </member>
        <member name="M:NLog.SetupLoadConfigurationExtensions.SetGlobalContextProperty(NLog.Config.ISetupLoadConfigurationBuilder,System.String,System.String)">
            <summary>
            Updates the dictionary <see cref="T:NLog.GlobalDiagnosticsContext"/> ${gdc:item=} with the name-value-pair
            </summary>
        </member>
        <member name="M:NLog.SetupLoadConfigurationExtensions.ForLogger(NLog.Config.ISetupLoadConfigurationBuilder,System.String,System.String)">
            <summary>
            Defines <see cref="T:NLog.Config.LoggingRule" /> for redirecting output from matching <see cref="T:NLog.Logger"/> to wanted targets.
            </summary>
            <param name="configBuilder">Fluent interface parameter.</param>
            <param name="loggerNamePattern">Logger name pattern to check which <see cref="T:NLog.Logger"/> names matches this rule</param>
            <param name="ruleName">Rule identifier to allow rule lookup</param>
        </member>
        <member name="M:NLog.SetupLoadConfigurationExtensions.ForLogger(NLog.Config.ISetupLoadConfigurationBuilder,NLog.LogLevel,System.String,System.String)">
            <summary>
            Defines <see cref="T:NLog.Config.LoggingRule" /> for redirecting output from matching <see cref="T:NLog.Logger"/> to wanted targets.
            </summary>
            <param name="configBuilder">Fluent interface parameter.</param>
            <param name="finalMinLevel">Restrict minimum LogLevel for <see cref="T:NLog.Logger"/> names that matches this rule</param>
            <param name="loggerNamePattern">Logger name pattern to check which <see cref="T:NLog.Logger"/> names matches this rule</param>
            <param name="ruleName">Rule identifier to allow rule lookup</param>
        </member>
        <member name="M:NLog.SetupLoadConfigurationExtensions.ForTarget(NLog.Config.ISetupLoadConfigurationBuilder,System.String)">
            <summary>
            Defines <see cref="T:NLog.Config.LoggingRule" /> for redirecting output from matching <see cref="T:NLog.Logger"/> to wanted targets.
            </summary>
            <param name="configBuilder">Fluent interface parameter.</param>
            <param name="targetName">Override the name for the target created</param>
        </member>
        <member name="M:NLog.SetupLoadConfigurationExtensions.FilterMinLevel(NLog.Config.ISetupConfigurationLoggingRuleBuilder,NLog.LogLevel)">
            <summary>
            Apply fast filtering based on <see cref="T:NLog.LogLevel"/>. Include LogEvents with same or worse severity as <paramref name="minLevel"/>.
            </summary>
            <param name="configBuilder">Fluent interface parameter.</param>
            <param name="minLevel">Minimum level that this rule matches</param>
        </member>
        <member name="M:NLog.SetupLoadConfigurationExtensions.FilterMaxLevel(NLog.Config.ISetupConfigurationLoggingRuleBuilder,NLog.LogLevel)">
            <summary>
            Apply fast filtering based on <see cref="T:NLog.LogLevel"/>. Include LogEvents with same or less severity as <paramref name="maxLevel"/>.
            </summary>
            <param name="configBuilder">Fluent interface parameter.</param>
            <param name="maxLevel">Maximum level that this rule matches</param>
        </member>
        <member name="M:NLog.SetupLoadConfigurationExtensions.FilterLevel(NLog.Config.ISetupConfigurationLoggingRuleBuilder,NLog.LogLevel)">
            <summary>
            Apply fast filtering based on <see cref="T:NLog.LogLevel"/>. Include LogEvents with severity that equals <paramref name="logLevel"/>.
            </summary>
            <param name="configBuilder">Fluent interface parameter.</param>
            <param name="logLevel">Single loglevel that this rule matches</param>
        </member>
        <member name="M:NLog.SetupLoadConfigurationExtensions.FilterLevels(NLog.Config.ISetupConfigurationLoggingRuleBuilder,NLog.LogLevel,NLog.LogLevel)">
            <summary>
            Apply fast filtering based on <see cref="T:NLog.LogLevel"/>. Include LogEvents with severity between <paramref name="minLevel"/> and <paramref name="maxLevel"/>.
            </summary>
            <param name="configBuilder">Fluent interface parameter.</param>
            <param name="minLevel">Minimum level that this rule matches</param>
            <param name="maxLevel">Maximum level that this rule matches</param>
        </member>
        <member name="M:NLog.SetupLoadConfigurationExtensions.FilterDynamic(NLog.Config.ISetupConfigurationLoggingRuleBuilder,NLog.Filters.Filter,System.Nullable{NLog.Filters.FilterResult})">
            <summary>
            Apply dynamic filtering logic for advanced control of when to redirect output to target.
            </summary>
            <remarks>
            Slower than using Logger-name or LogLevel-severity, because of <see cref="T:NLog.LogEventInfo"/> allocation.
            </remarks>
            <param name="configBuilder">Fluent interface parameter.</param>
            <param name="filter">Filter for controlling whether to write</param>
            <param name="filterDefaultAction">Default action if none of the filters match</param>
        </member>
        <member name="M:NLog.SetupLoadConfigurationExtensions.FilterDynamic(NLog.Config.ISetupConfigurationLoggingRuleBuilder,System.Func{NLog.LogEventInfo,NLog.Filters.FilterResult},System.Nullable{NLog.Filters.FilterResult})">
            <summary>
            Apply dynamic filtering logic for advanced control of when to redirect output to target.
            </summary>
            <remarks>
            Slower than using Logger-name or LogLevel-severity, because of <see cref="T:NLog.LogEventInfo"/> allocation.
            </remarks>
            <param name="configBuilder">Fluent interface parameter.</param>
            <param name="filterMethod">Delegate for controlling whether to write</param>
            <param name="filterDefaultAction">Default action if none of the filters match</param>
        </member>
        <member name="M:NLog.SetupLoadConfigurationExtensions.FilterDynamicIgnore(NLog.Config.ISetupConfigurationLoggingRuleBuilder,System.Func{NLog.LogEventInfo,System.Boolean},System.Boolean)">
            <summary>
            Dynamic filtering of LogEvent, where it will be ignored when matching filter-method-delegate
            </summary>
            <remarks>
            Slower than using Logger-name or LogLevel-severity, because of <see cref="T:NLog.LogEventInfo"/> allocation.
            </remarks>
            <param name="configBuilder">Fluent interface parameter.</param>
            <param name="filterMethod">Delegate for controlling whether to write</param>
            <param name="final">LogEvent will on match also be ignored by following logging-rules</param>
        </member>
        <member name="M:NLog.SetupLoadConfigurationExtensions.FilterDynamicLog(NLog.Config.ISetupConfigurationLoggingRuleBuilder,System.Func{NLog.LogEventInfo,System.Boolean},System.Boolean)">
            <summary>
            Dynamic filtering of LogEvent, where it will be logged when matching filter-method-delegate
            </summary>
            <remarks>
            Slower than using Logger-name or LogLevel-severity, because of <see cref="T:NLog.LogEventInfo"/> allocation.
            </remarks>
            <param name="configBuilder">Fluent interface parameter.</param>
            <param name="filterMethod">Delegate for controlling whether to write</param>
            <param name="final">LogEvent will not be evaluated by following logging-rules</param>
        </member>
        <member name="M:NLog.SetupLoadConfigurationExtensions.TopRule(NLog.Config.ISetupConfigurationLoggingRuleBuilder,System.Boolean)">
            <summary>
            Move the <see cref="T:NLog.Config.LoggingRule" /> to the top, to match before any of the existing <see cref="P:NLog.Config.LoggingConfiguration.LoggingRules"/>
            </summary>
        </member>
        <member name="M:NLog.SetupLoadConfigurationExtensions.WriteTo(NLog.Config.ISetupConfigurationTargetBuilder,NLog.Targets.Target)">
            <summary>
            Redirect output from matching <see cref="T:NLog.Logger"/> to the provided <paramref name="target"/>
            </summary>
            <param name="configBuilder">Fluent interface parameter.</param>
            <param name="target">Target that should be written to.</param>
            <returns>Fluent interface for configuring targets for the new LoggingRule.</returns>
        </member>
        <member name="M:NLog.SetupLoadConfigurationExtensions.WriteTo(NLog.Config.ISetupConfigurationTargetBuilder,NLog.Targets.Target[])">
            <summary>
            Redirect output from matching <see cref="T:NLog.Logger"/> to the provided <paramref name="targets"/>
            </summary>
            <param name="configBuilder">Fluent interface parameter.</param>
            <param name="targets">Target-collection that should be written to.</param>
            <returns>Fluent interface for configuring targets for the new LoggingRule.</returns>
        </member>
        <member name="M:NLog.SetupLoadConfigurationExtensions.WriteTo(NLog.Config.ISetupConfigurationTargetBuilder,NLog.Config.ISetupConfigurationTargetBuilder)">
            <summary>
            Redirect output from matching <see cref="T:NLog.Logger"/> to the provided <paramref name="targetBuilder"/>
            </summary>
            <param name="configBuilder">Fluent interface parameter.</param>
            <param name="targetBuilder">Target-collection that should be written to.</param>
            <returns>Fluent interface for configuring targets for the new LoggingRule.</returns>
        </member>
        <member name="M:NLog.SetupLoadConfigurationExtensions.WriteToNil(NLog.Config.ISetupConfigurationLoggingRuleBuilder,NLog.LogLevel)">
            <summary>
            Discard output from matching <see cref="T:NLog.Logger"/>, so it will not reach any following <see cref="P:NLog.Config.LoggingConfiguration.LoggingRules"/>.
            </summary>
            <param name="configBuilder">Fluent interface parameter.</param>
            <param name="finalMinLevel">Only discard output from matching Logger when below minimum LogLevel</param>
        </member>
        <member name="M:NLog.SetupLoadConfigurationExtensions.FirstTarget(NLog.Config.ISetupConfigurationTargetBuilder)">
            <summary>
            Returns first target registered
            </summary>
        </member>
        <member name="M:NLog.SetupLoadConfigurationExtensions.FirstTarget``1(NLog.Config.ISetupConfigurationTargetBuilder)">
            <summary>
            Returns first target registered with the specified type
            </summary>
            <typeparam name="T">Type of target</typeparam>
        </member>
        <member name="M:NLog.SetupLoadConfigurationExtensions.WriteToMethodCall(NLog.Config.ISetupConfigurationTargetBuilder,System.Action{NLog.LogEventInfo,System.Object[]},NLog.Layouts.Layout[])">
            <summary>
            Write to <see cref="T:NLog.Targets.MethodCallTarget"/>
            </summary>
            <param name="configBuilder">Fluent interface parameter.</param>
            <param name="logEventAction">Method to call on logevent</param>
            <param name="layouts">Layouts to render object[]-args before calling <paramref name="logEventAction"/></param>
        </member>
        <member name="M:NLog.SetupLoadConfigurationExtensions.WriteToConsole(NLog.Config.ISetupConfigurationTargetBuilder,NLog.Layouts.Layout,System.Text.Encoding,System.Boolean,System.Boolean,System.Boolean)">
            <summary>
            Write to <see cref="T:NLog.Targets.ConsoleTarget"/>
            </summary>
            <param name="configBuilder">Fluent interface parameter.</param>
            <param name="layout">Override the default Layout for output</param>
            <param name="encoding">Override the default Encoding for output (Ex. UTF8)</param>
            <param name="stderr">Write to stderr instead of standard output (stdout)</param>
            <param name="detectConsoleAvailable">Skip overhead from writing to console, when not available (Ex. running as Windows Service)</param>
            <param name="writeBuffered">Enable batch writing of logevents, instead of Console.WriteLine for each logevent (Requires <see cref="M:NLog.SetupLoadConfigurationExtensions.WithAsync(NLog.Config.ISetupConfigurationTargetBuilder,NLog.Targets.Wrappers.AsyncTargetWrapperOverflowAction,System.Int32,System.Int32)"/>)</param>
        </member>
        <member name="M:NLog.SetupLoadConfigurationExtensions.WriteToColoredConsole(NLog.Config.ISetupConfigurationTargetBuilder,NLog.Layouts.Layout,System.Boolean,System.Text.Encoding,System.Boolean,System.Boolean,System.Boolean)">
            <summary>
            Write to <see cref="T:NLog.Targets.ColoredConsoleTarget"/> and color log-messages based on <see cref="T:NLog.LogLevel"/>
            </summary>
            <param name="configBuilder">Fluent interface parameter.</param>
            <param name="layout">Override the default Layout for output</param>
            <param name="highlightWordLevel">Highlight only the Level-part</param>
            <param name="encoding">Override the default Encoding for output (Ex. UTF8)</param>
            <param name="stderr">Write to stderr instead of standard output (stdout)</param>
            <param name="detectConsoleAvailable">Skip overhead from writing to console, when not available (Ex. running as Windows Service)</param>
            <param name="enableAnsiOutput">Enables output using ANSI Color Codes (Windows console does not support this by default)</param>
        </member>
        <member name="M:NLog.SetupLoadConfigurationExtensions.WriteToTrace(NLog.Config.ISetupConfigurationTargetBuilder,NLog.Layouts.Layout,System.Boolean)">
            <summary>
            Write to <see cref="T:NLog.Targets.TraceTarget"/>
            </summary>
            <param name="configBuilder"></param>
            <param name="layout">Override the default Layout for output</param>
            <param name="rawWrite">Force use <see cref="M:System.Diagnostics.Trace.WriteLine(System.String)"/> independent of <see cref="T:NLog.LogLevel"/></param>
        </member>
        <member name="M:NLog.SetupLoadConfigurationExtensions.WriteToDebug(NLog.Config.ISetupConfigurationTargetBuilder,NLog.Layouts.Layout)">
            <summary>
            Write to <see cref="T:NLog.Targets.DebugSystemTarget"/>
            </summary>
            <param name="configBuilder"></param>
            <param name="layout">Override the default Layout for output</param>
        </member>
        <member name="M:NLog.SetupLoadConfigurationExtensions.WriteToDebugConditional(NLog.Config.ISetupConfigurationTargetBuilder,NLog.Layouts.Layout)">
            <summary>
            Write to <see cref="T:NLog.Targets.DebugSystemTarget"/> (when DEBUG-build)
            </summary>
            <param name="configBuilder"></param>
            <param name="layout">Override the default Layout for output</param>
        </member>
        <member name="M:NLog.SetupLoadConfigurationExtensions.WriteToFile(NLog.Config.ISetupConfigurationTargetBuilder,NLog.Layouts.Layout,NLog.Layouts.Layout,System.Text.Encoding,NLog.Targets.LineEndingMode,System.Boolean,System.Int64,System.Int32,System.Int32)">
            <summary>
            Write to <see cref="T:NLog.Targets.FileTarget"/>
            </summary>
            <param name="configBuilder">Fluent interface parameter.</param>
            <param name="fileName"></param>
            <param name="layout">Override the default Layout for output</param>
            <param name="encoding">Override the default Encoding for output (Default = UTF8)</param>
            <param name="lineEnding">Override the default line ending characters (Ex. <see cref="F:NLog.Targets.LineEndingMode.LF"/> without CR)</param>
            <param name="keepFileOpen">Keep log file open instead of opening and closing it on each logging event</param>
            <param name="archiveAboveSize">Size in bytes where log files will be automatically archived.</param>
            <param name="maxArchiveFiles">Maximum number of archive files that should be kept.</param>
            <param name="maxArchiveDays">Maximum days of archive files that should be kept.</param>
        </member>
        <member name="M:NLog.SetupLoadConfigurationExtensions.WriteToFile(NLog.Config.ISetupConfigurationTargetBuilder,NLog.Layouts.Layout,NLog.Layouts.Layout,System.Text.Encoding,NLog.Targets.LineEndingMode,System.Boolean,System.Boolean,System.Int64,System.Int32,System.Int32)">
            <summary>
            Write to <see cref="T:NLog.Targets.FileTarget"/>
            </summary>
            <param name="configBuilder">Fluent interface parameter.</param>
            <param name="fileName"></param>
            <param name="layout">Override the default Layout for output</param>
            <param name="encoding">Override the default Encoding for output (Default = UTF8)</param>
            <param name="lineEnding">Override the default line ending characters (Ex. <see cref="F:NLog.Targets.LineEndingMode.LF"/> without CR)</param>
            <param name="keepFileOpen">Keep log file open instead of opening and closing it on each logging event</param>
            <param name="concurrentWrites">Activate multi-process synchronization using global mutex on the operating system</param>
            <param name="archiveAboveSize">Size in bytes where log files will be automatically archived.</param>
            <param name="maxArchiveFiles">Maximum number of archive files that should be kept.</param>
            <param name="maxArchiveDays">Maximum days of archive files that should be kept.</param>
        </member>
        <member name="M:NLog.SetupLoadConfigurationExtensions.WithWrapper(NLog.Config.ISetupConfigurationTargetBuilder,System.Func{NLog.Targets.Target,NLog.Targets.Target})">
            <summary>
            Applies target wrapper for existing <see cref="P:NLog.Config.LoggingRule.Targets"/>
            </summary>
            <param name="configBuilder">Fluent interface parameter.</param>
            <param name="wrapperFactory">Factory method for creating target-wrapper</param>
        </member>
        <member name="M:NLog.SetupLoadConfigurationExtensions.WithAsync(NLog.Config.ISetupConfigurationTargetBuilder,NLog.Targets.Wrappers.AsyncTargetWrapperOverflowAction,System.Int32,System.Int32)">
            <summary>
            Applies <see cref="T:NLog.Targets.Wrappers.AsyncTargetWrapper"/> for existing <see cref="P:NLog.Config.LoggingRule.Targets"/> for asynchronous background writing
            </summary>
            <param name="configBuilder">Fluent interface parameter.</param>
            <param name="overflowAction">Action to take when queue overflows</param>
            <param name="queueLimit">Queue size limit for pending logevents</param>
            <param name="batchSize">Batch size when writing on the background thread</param>
        </member>
        <member name="M:NLog.SetupLoadConfigurationExtensions.WithBuffering(NLog.Config.ISetupConfigurationTargetBuilder,System.Nullable{System.Int32},System.Nullable{System.TimeSpan},System.Nullable{System.Boolean},System.Nullable{NLog.Targets.Wrappers.BufferingTargetWrapperOverflowAction})">
            <summary>
            Applies <see cref="T:NLog.Targets.Wrappers.BufferingTargetWrapper"/> for existing <see cref="P:NLog.Config.LoggingRule.Targets"/> for throttled writing
            </summary>
            <param name="configBuilder">Fluent interface parameter.</param>
            <param name="bufferSize">Buffer size limit for pending logevents</param>
            <param name="flushTimeout">Timeout for when the buffer will flush automatically using background thread</param>
            <param name="slidingTimeout">Restart timeout when logevent is written</param>
            <param name="overflowAction">Action to take when buffer overflows</param>
        </member>
        <member name="M:NLog.SetupLoadConfigurationExtensions.WithAutoFlush(NLog.Config.ISetupConfigurationTargetBuilder,System.Func{NLog.LogEventInfo,System.Boolean},System.Nullable{System.Boolean})">
            <summary>
            Applies <see cref="T:NLog.Targets.Wrappers.AutoFlushTargetWrapper"/> for existing <see cref="P:NLog.Config.LoggingRule.Targets"/> for flushing after conditional event
            </summary>
            <param name="configBuilder">Fluent interface parameter.</param>
            <param name="conditionMethod">Method delegate that controls whether logevent should force flush.</param>
            <param name="flushOnConditionOnly">Only flush when <paramref name="conditionMethod"/> triggers (Ignore config-reload and config-shutdown)</param>
        </member>
        <member name="M:NLog.SetupLoadConfigurationExtensions.WithRetry(NLog.Config.ISetupConfigurationTargetBuilder,System.Nullable{System.Int32},System.Nullable{System.TimeSpan})">
            <summary>
            Applies <see cref="T:NLog.Targets.Wrappers.RetryingTargetWrapper"/> for existing <see cref="P:NLog.Config.LoggingRule.Targets"/> for retrying after failure
            </summary>
            <param name="configBuilder">Fluent interface parameter.</param>
            <param name="retryCount">Number of retries that should be attempted on the wrapped target in case of a failure.</param>
            <param name="retryDelay">Time to wait between retries</param>
        </member>
        <member name="M:NLog.SetupLoadConfigurationExtensions.WithFallback(NLog.Config.ISetupConfigurationTargetBuilder,NLog.Targets.Target,System.Boolean)">
            <summary>
            Applies <see cref="T:NLog.Targets.Wrappers.FallbackGroupTarget"/> for existing <see cref="P:NLog.Config.LoggingRule.Targets"/> to fallback on failure.
            </summary>
            <param name="configBuilder">Fluent interface parameter.</param>
            <param name="fallbackTarget">Target to use for fallback</param>
            <param name="returnToFirstOnSuccess">Whether to return to the first target after any successful write</param>
        </member>
        <member name="T:NLog.SetupLogFactoryBuilderExtensions">
            <summary>
            Extension methods to setup general option before loading NLog LoggingConfiguration
            </summary>
        </member>
        <member name="M:NLog.SetupLogFactoryBuilderExtensions.SetTimeSource(NLog.Config.ISetupLogFactoryBuilder,NLog.Time.TimeSource)">
            <summary>
            Configures the global time-source used for all logevents
            </summary>
            <remarks>
            Available by default: <see cref="T:NLog.Time.AccurateLocalTimeSource"/>, <see cref="T:NLog.Time.AccurateUtcTimeSource"/>, <see cref="T:NLog.Time.FastLocalTimeSource"/>, <see cref="T:NLog.Time.FastUtcTimeSource"/>
            </remarks>
        </member>
        <member name="M:NLog.SetupLogFactoryBuilderExtensions.SetTimeSourcAccurateUtc(NLog.Config.ISetupLogFactoryBuilder)">
            <summary>
            Configures the global time-source used for all logevents to use <see cref="T:NLog.Time.AccurateUtcTimeSource"/>
            </summary>
        </member>
        <member name="M:NLog.SetupLogFactoryBuilderExtensions.SetTimeSourcAccurateLocal(NLog.Config.ISetupLogFactoryBuilder)">
            <summary>
            Configures the global time-source used for all logevents to use <see cref="T:NLog.Time.AccurateLocalTimeSource"/>
            </summary>
        </member>
        <member name="M:NLog.SetupLogFactoryBuilderExtensions.SetGlobalContextProperty(NLog.Config.ISetupLogFactoryBuilder,System.String,System.Object)">
            <summary>
            Updates the dictionary <see cref="T:NLog.GlobalDiagnosticsContext"/> ${gdc:item=} with the name-value-pair
            </summary>
        </member>
        <member name="M:NLog.SetupLogFactoryBuilderExtensions.SetAutoShutdown(NLog.Config.ISetupLogFactoryBuilder,System.Boolean)">
            <summary>
            Sets whether to automatically call <see cref="M:NLog.LogFactory.Shutdown"/> on AppDomain.Unload or AppDomain.ProcessExit
            </summary>
        </member>
        <member name="M:NLog.SetupLogFactoryBuilderExtensions.SetDefaultCultureInfo(NLog.Config.ISetupLogFactoryBuilder,System.Globalization.CultureInfo)">
            <summary>
            Sets the default culture info to use as <see cref="P:NLog.LogEventInfo.FormatProvider"/>.
            </summary>
        </member>
        <member name="M:NLog.SetupLogFactoryBuilderExtensions.SetGlobalThreshold(NLog.Config.ISetupLogFactoryBuilder,NLog.LogLevel)">
            <summary>
            Sets the global log level threshold. Log events below this threshold are not logged.
            </summary>
        </member>
        <member name="M:NLog.SetupLogFactoryBuilderExtensions.SetThrowConfigExceptions(NLog.Config.ISetupLogFactoryBuilder,System.Boolean)">
            <summary>
            Gets or sets a value indicating whether <see cref="T:NLog.NLogConfigurationException"/> should be thrown on configuration errors
            </summary>
        </member>
        <member name="M:NLog.SetupLogFactoryBuilderExtensions.AddCallSiteHiddenAssembly(NLog.Config.ISetupLogFactoryBuilder,System.Reflection.Assembly)">
            <summary>
            Mark Assembly as hidden, so Assembly methods are excluded when resolving ${callsite} from StackTrace
            </summary>
        </member>
        <member name="M:NLog.SetupLogFactoryBuilderExtensions.AddCallSiteHiddenClassType(NLog.Config.ISetupLogFactoryBuilder,System.Type)">
            <summary>
            Mark Type as hidden, so Type methods are excluded when resolving ${callsite} from StackTrace
            </summary>
        </member>
        <member name="T:NLog.SetupSerializationBuilderExtensions">
            <summary>
            Extension methods to setup NLog extensions, so they are known when loading NLog LoggingConfiguration
            </summary>
        </member>
        <member name="M:NLog.SetupSerializationBuilderExtensions.ParseMessageTemplates(NLog.Config.ISetupSerializationBuilder,System.Nullable{System.Boolean})">
            <summary>
            Enable/disables the NLog Message Template Parsing:
            <para>- True = Always use NLog mesage-template-parser and formatting.</para>
            <para>- False = Never use NLog-parser and only use string.Format (Disable support for message-template-syntax).</para>
            <para>- Null = Auto detection of message-template-syntax, with fallback to string.Format (Default Behavior).</para>
            </summary>
        </member>
        <member name="M:NLog.SetupSerializationBuilderExtensions.RegisterJsonConverter(NLog.Config.ISetupSerializationBuilder,NLog.IJsonConverter)">
            <summary>
            Overrides the active <see cref="T:NLog.IJsonConverter"/> with a new custom implementation
            </summary>
        </member>
        <member name="M:NLog.SetupSerializationBuilderExtensions.RegisterValueFormatter(NLog.Config.ISetupSerializationBuilder,NLog.IValueFormatter)">
            <summary>
            Overrides the active <see cref="T:NLog.IValueFormatter"/> with a new custom implementation
            </summary>
        </member>
        <member name="M:NLog.SetupSerializationBuilderExtensions.RegisterObjectTransformation``1(NLog.Config.ISetupSerializationBuilder,System.Func{``0,System.Object})">
            <summary>
            Registers object Type transformation from dangerous (massive) object to safe (reduced) object
            </summary>
        </member>
        <member name="M:NLog.SetupSerializationBuilderExtensions.RegisterObjectTransformation(NLog.Config.ISetupSerializationBuilder,System.Type,System.Func{System.Object,System.Object})">
            <summary>
            Registers object Type transformation from dangerous (massive) object to safe (reduced) object
            </summary>
        </member>
        <member name="T:NLog.Targets.ArchiveNumberingMode">
            <summary>
            Specifies the way archive numbering is performed.
            </summary>
        </member>
        <member name="F:NLog.Targets.ArchiveNumberingMode.Sequence">
            <summary>
            Sequence style numbering. The most recent archive has the highest number.
            </summary>
        </member>
        <member name="F:NLog.Targets.ArchiveNumberingMode.Rolling">
            <summary>
            Rolling style numbering (the most recent is always #0 then #1, ..., #N.
            </summary>
        </member>
        <member name="F:NLog.Targets.ArchiveNumberingMode.Date">
            <summary>
            Date style numbering.  Archives will be stamped with the prior period
            (Year, Month, Day, Hour, Minute) datetime.
            </summary>
        </member>
        <member name="F:NLog.Targets.ArchiveNumberingMode.DateAndSequence">
            <summary>
            Date and sequence style numbering.
            Archives will be stamped with the prior period (Year, Month, Day) datetime.
            The most recent archive has the highest number (in combination with the date).
            </summary>
        </member>
        <member name="T:NLog.Targets.AsyncTaskTarget">
             <summary>
             Abstract Target with async Task support
             </summary>
             <remarks>
             <a href="https://github.com/NLog/NLog/wiki/How-to-write-a-custom-async-target">See NLog Wiki</a>
             </remarks>
             <example><code>
             [Target("MyFirst")]
             public sealed class MyFirstTarget : AsyncTaskTarget
             {
                public MyFirstTarget()
                {
                    this.Host = "localhost";
                }
            
                [RequiredParameter]
                public Layout Host { get; set; }
            
                protected override Task WriteAsyncTask(LogEventInfo logEvent, CancellationToken token)
                {
                    string logMessage = this.RenderLogEvent(this.Layout, logEvent);
                    string hostName = this.RenderLogEvent(this.Host, logEvent);
                    return SendTheMessageToRemoteHost(hostName, logMessage);
                }
            
                private async Task SendTheMessageToRemoteHost(string hostName, string message)
                {
                    // To be implemented
                }
             }
             </code></example>
             <seealso href="https://github.com/NLog/NLog/wiki/How-to-write-a-custom-async-target">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.Targets.AsyncTaskTarget.TaskDelayMilliseconds">
            <summary>
            How many milliseconds to delay the actual write operation to optimize for batching
            </summary>
            <docgen category='Buffering Options' order='100' />
        </member>
        <member name="P:NLog.Targets.AsyncTaskTarget.TaskTimeoutSeconds">
            <summary>
            How many seconds a Task is allowed to run before it is cancelled.
            </summary>
            <docgen category='Buffering Options' order='100' />
        </member>
        <member name="P:NLog.Targets.AsyncTaskTarget.RetryCount">
            <summary>
            How many attempts to retry the same Task, before it is aborted
            </summary>
            <docgen category='Buffering Options' order='100' />
        </member>
        <member name="P:NLog.Targets.AsyncTaskTarget.RetryDelayMilliseconds">
            <summary>
            How many milliseconds to wait before next retry (will double with each retry)
            </summary>
            <docgen category='Buffering Options' order='100' />
        </member>
        <member name="P:NLog.Targets.AsyncTaskTarget.ForceLockingQueue">
            <summary>
            Gets or sets whether to use the locking queue, instead of a lock-free concurrent queue
            The locking queue is less concurrent when many logger threads, but reduces memory allocation
            </summary>
            <docgen category='Buffering Options' order='100' />
        </member>
        <member name="P:NLog.Targets.AsyncTaskTarget.OverflowAction">
            <summary>
            Gets or sets the action to be taken when the lazy writer thread request queue count
            exceeds the set limit.
            </summary>
            <docgen category='Buffering Options' order='100' />
        </member>
        <member name="P:NLog.Targets.AsyncTaskTarget.QueueLimit">
            <summary>
            Gets or sets the limit on the number of requests in the lazy writer thread request queue.
            </summary>
            <docgen category='Buffering Options' order='100' />
        </member>
        <member name="P:NLog.Targets.AsyncTaskTarget.BatchSize">
            <summary>
            Gets or sets the number of log events that should be processed in a batch
            by the lazy writer thread.
            </summary>
            <docgen category='Buffering Options' order='100' />
        </member>
        <member name="P:NLog.Targets.AsyncTaskTarget.TaskScheduler">
            <summary>
            Task Scheduler used for processing async Tasks
            </summary>
        </member>
        <member name="M:NLog.Targets.AsyncTaskTarget.#ctor">
            <summary>
            Constructor
            </summary>
        </member>
        <member name="M:NLog.Targets.AsyncTaskTarget.InitializeTarget">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Targets.AsyncTaskTarget.WriteAsyncTask(NLog.LogEventInfo,System.Threading.CancellationToken)">
             <summary>
             Override this to provide async task for writing a single logevent.
             <example>
             Example of how to override this method, and call custom async method
             <code>
             protected override Task WriteAsyncTask(LogEventInfo logEvent, CancellationToken token)
             {
                return CustomWriteAsync(logEvent, token);
             }
            
             private async Task CustomWriteAsync(LogEventInfo logEvent, CancellationToken token)
             {
                 await MyLogMethodAsync(logEvent, token).ConfigureAwait(false);
             }
             </code></example>
             </summary>
             <param name="logEvent">The log event.</param>
             <param name="cancellationToken">The cancellation token</param>
             <returns></returns>
        </member>
        <member name="M:NLog.Targets.AsyncTaskTarget.WriteAsyncTask(System.Collections.Generic.IList{NLog.LogEventInfo},System.Threading.CancellationToken)">
            <summary>
            Override this to provide async task for writing a batch of logevents.
            </summary>
            <param name="logEvents">A batch of logevents.</param>
            <param name="cancellationToken">The cancellation token</param>
            <returns></returns>
        </member>
        <member name="M:NLog.Targets.AsyncTaskTarget.RetryFailedAsyncTask(System.Exception,System.Threading.CancellationToken,System.Int32,System.TimeSpan@)">
            <summary>
            Handle cleanup after failed write operation
            </summary>
            <param name="exception">Exception from previous failed Task</param>
            <param name="cancellationToken">The cancellation token</param>
            <param name="retryCountRemaining">Number of retries remaining</param>
            <param name="retryDelay">Time to sleep before retrying</param>
            <returns>Should attempt retry</returns>
        </member>
        <member name="M:NLog.Targets.AsyncTaskTarget.Write(NLog.LogEventInfo)">
            <summary>
            Block for override. Instead override <see cref="M:NLog.Targets.AsyncTaskTarget.WriteAsyncTask(NLog.LogEventInfo,System.Threading.CancellationToken)"/>
            </summary>
        </member>
        <member name="M:NLog.Targets.AsyncTaskTarget.Write(System.Collections.Generic.IList{NLog.Common.AsyncLogEventInfo})">
            <summary>
            Block for override. Instead override <see cref="M:NLog.Targets.AsyncTaskTarget.WriteAsyncTask(System.Collections.Generic.IList{NLog.LogEventInfo},System.Threading.CancellationToken)"/>
            </summary>
        </member>
        <member name="M:NLog.Targets.AsyncTaskTarget.Write(NLog.Common.AsyncLogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Targets.AsyncTaskTarget.WriteAsyncThreadSafe(NLog.Common.AsyncLogEventInfo)">
            <summary>
            Write to queue without locking <see cref="P:NLog.Targets.Target.SyncRoot"/>
            </summary>
            <param name="logEvent"></param>
        </member>
        <member name="M:NLog.Targets.AsyncTaskTarget.WriteAsyncThreadSafe(System.Collections.Generic.IList{NLog.Common.AsyncLogEventInfo})">
            <summary>
            Block for override. Instead override <see cref="M:NLog.Targets.AsyncTaskTarget.WriteAsyncTask(System.Collections.Generic.IList{NLog.LogEventInfo},System.Threading.CancellationToken)"/>
            </summary>
        </member>
        <member name="M:NLog.Targets.AsyncTaskTarget.WriteFailedNotInitialized(NLog.Common.AsyncLogEventInfo,System.Exception)">
             <summary>
             LogEvent is written to target, but target failed to successfully initialize
            
             Enqueue logevent for later processing when target failed to initialize because of unresolved service dependency.
             </summary>
        </member>
        <member name="M:NLog.Targets.AsyncTaskTarget.FlushAsync(NLog.Common.AsyncContinuation)">
            <summary>
            Schedules notification of when all messages has been written
            </summary>
            <param name="asyncContinuation"></param>
        </member>
        <member name="M:NLog.Targets.AsyncTaskTarget.CloseTarget">
            <summary>
            Closes Target by updating CancellationToken
            </summary>
        </member>
        <member name="M:NLog.Targets.AsyncTaskTarget.Dispose(System.Boolean)">
            <summary>
            Releases any managed resources
            </summary>
            <param name="disposing"></param>
        </member>
        <member name="M:NLog.Targets.AsyncTaskTarget.TaskStartNext(System.Object,System.Boolean)">
            <summary>
            Checks the internal queue for the next <see cref="T:NLog.LogEventInfo"/> to create a new task for
            </summary>
            <param name="previousTask">Used for race-condition validation between task-completion and timeout</param>
            <param name="fullBatchCompleted">Signals whether previousTask completed an almost full BatchSize</param>
        </member>
        <member name="M:NLog.Targets.AsyncTaskTarget.WriteAsyncTaskWithRetry(System.Threading.Tasks.Task,System.Collections.Generic.IList{NLog.LogEventInfo},System.Threading.CancellationToken,System.Int32)">
            <summary>
            Generates recursive task-chain to perform retry of writing logevents with increasing retry-delay
            </summary>
        </member>
        <member name="M:NLog.Targets.AsyncTaskTarget.TaskCreation(System.Collections.Generic.IList{NLog.Common.AsyncLogEventInfo})">
            <summary>
            Creates new task to handle the writing of the input <see cref="T:NLog.LogEventInfo"/>
            </summary>
            <param name="logEvents">LogEvents to write</param>
            <returns>New Task created [true / false]</returns>
        </member>
        <member name="M:NLog.Targets.AsyncTaskTarget.TaskCompletion(System.Threading.Tasks.Task,System.Object)">
            <summary>
            Handles that scheduled task has completed (successfully or failed), and starts the next pending task
            </summary>
            <param name="completedTask">Task just completed</param>
            <param name="continuation">AsyncContinuation to notify of success or failure</param>
        </member>
        <member name="M:NLog.Targets.AsyncTaskTarget.TaskTimeout(System.Object)">
            <summary>
            Timer method, that is fired when pending task fails to complete within timeout
            </summary>
            <param name="state"></param>
        </member>
        <member name="T:NLog.Targets.ChainsawTarget">
            <summary>
            Sends log messages to the remote instance of Chainsaw application from log4j.
            </summary>
            <remarks>
            <a href="https://github.com/nlog/nlog/wiki/Chainsaw-target">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/nlog/nlog/wiki/Chainsaw-target">Documentation on NLog Wiki</seealso>
            <example>
            <p>
            To set up the target in the <a href="https://github.com/NLog/NLog/wiki/Configuration-file">configuration file</a>,
            use the following syntax:
            </p>
            <code lang="XML" source="examples/targets/Configuration File/Chainsaw/NLog.config" />
            <p>
            To set up the log target programmatically use code like this:
            </p>
            <code lang="C#" source="examples/targets/Configuration API/Chainsaw/Simple/Example.cs" />
            </example>
        </member>
        <member name="M:NLog.Targets.ChainsawTarget.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.ChainsawTarget" /> class.
            </summary>
        </member>
        <member name="M:NLog.Targets.ChainsawTarget.#ctor(System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.ChainsawTarget"/> class with a name.
            </summary>
            <param name="name">Name of the target.</param>
        </member>
        <member name="T:NLog.Targets.ColoredConsoleAnsiPrinter">
            <summary>
            Color formatting for <see cref="T:NLog.Targets.ColoredConsoleTarget"/> using ANSI Color Codes
            </summary>
        </member>
        <member name="M:NLog.Targets.ColoredConsoleAnsiPrinter.GetForegroundColorEscapeCode(System.ConsoleColor)">
            <summary>
            Not using bold to get light colors, as it has to be cleared
            </summary>
        </member>
        <member name="M:NLog.Targets.ColoredConsoleAnsiPrinter.GetBackgroundColorEscapeCode(System.ConsoleColor)">
            <summary>
            Not using bold to get light colors, as it has to be cleared (And because it only works for text, and not background)
            </summary>
        </member>
        <member name="P:NLog.Targets.ColoredConsoleAnsiPrinter.TerminalDefaultColorEscapeCode">
            <summary>
            Resets both foreground and background color.
            </summary>
        </member>
        <member name="P:NLog.Targets.ColoredConsoleAnsiPrinter.DefaultConsoleRowHighlightingRules">
            <summary>
            ANSI have 8 color-codes (30-37) by default. The "bright" (or "intense") color-codes (90-97) are extended values not supported by all terminals
            </summary>
        </member>
        <member name="T:NLog.Targets.ColoredConsoleSystemPrinter">
            <summary>
            Color formatting for <see cref="T:NLog.Targets.ColoredConsoleTarget"/> using <see cref="P:System.Console.ForegroundColor"/>
            and <see cref="P:System.Console.BackgroundColor"/>
            </summary>
        </member>
        <member name="T:NLog.Targets.ColoredConsoleTarget">
            <summary>
            Writes log messages to the console with customizable coloring.
            </summary>
            <remarks>
            <a href="https://github.com/nlog/nlog/wiki/ColoredConsole-target">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/nlog/nlog/wiki/ColoredConsole-target">Documentation on NLog Wiki</seealso>
            <example>
            <p>
            To set up the target in the <a href="https://github.com/NLog/NLog/wiki/Configuration-file">configuration file</a>,
            use the following syntax:
            </p>
            <code lang="XML" source="examples/targets/Configuration File/ColoredConsole/NLog.config" />
            <p>
            To set up the log target programmatically use code like this:
            </p>
            <code lang="C#" source="examples/targets/Configuration API/ColoredConsole/Simple/Example.cs" />
            </example>
        </member>
        <member name="F:NLog.Targets.ColoredConsoleTarget._pauseLogging">
             <summary>
             Should logging being paused/stopped because of the race condition bug in Console.Writeline?
             </summary>
             <remarks>
               Console.Out.Writeline / Console.Error.Writeline could throw 'IndexOutOfRangeException', which is a bug.
             See https://stackoverflow.com/questions/33915790/console-out-and-console-error-race-condition-error-in-a-windows-service-written
             and https://connect.microsoft.com/VisualStudio/feedback/details/2057284/console-out-probable-i-o-race-condition-issue-in-multi-threaded-windows-service
            
             Full error:
               Error during session close: System.IndexOutOfRangeException: Probable I/ O race condition detected while copying memory.
               The I/ O package is not thread safe by default. In multi-threaded applications,
               a stream must be accessed in a thread-safe way, such as a thread - safe wrapper returned by TextReader's or
               TextWriter's Synchronized methods.This also applies to classes like StreamWriter and StreamReader.
            
             </remarks>
        </member>
        <member name="M:NLog.Targets.ColoredConsoleTarget.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.ColoredConsoleTarget" /> class.
            </summary>
            <remarks>
            The default value of the layout is: <code>${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}</code>
            </remarks>
        </member>
        <member name="M:NLog.Targets.ColoredConsoleTarget.#ctor(System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.ColoredConsoleTarget" /> class.
            </summary>
            <remarks>
            The default value of the layout is: <code>${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}</code>
            </remarks>
            <param name="name">Name of the target.</param>
        </member>
        <member name="P:NLog.Targets.ColoredConsoleTarget.ErrorStream">
            <summary>
            Obsolete and replaced by <see cref="P:NLog.Targets.ColoredConsoleTarget.StdErr"/> with NLog v5.
            Gets or sets a value indicating whether the error stream (stderr) should be used instead of the output stream (stdout).
            </summary>
            <docgen category='Console Options' order='10' />
        </member>
        <member name="P:NLog.Targets.ColoredConsoleTarget.StdErr">
            <summary>
            Gets or sets a value indicating whether to send the log messages to the standard error instead of the standard output.
            </summary>
            <docgen category='Console Options' order='10' />
        </member>
        <member name="P:NLog.Targets.ColoredConsoleTarget.UseDefaultRowHighlightingRules">
            <summary>
            Gets or sets a value indicating whether to use default row highlighting rules.
            </summary>
            <remarks>
            The default rules are:
            <table>
            <tr>
            <th>Condition</th>
            <th>Foreground Color</th>
            <th>Background Color</th>
            </tr>
            <tr>
            <td>level == LogLevel.Fatal</td>
            <td>Red</td>
            <td>NoChange</td>
            </tr>
            <tr>
            <td>level == LogLevel.Error</td>
            <td>Yellow</td>
            <td>NoChange</td>
            </tr>
            <tr>
            <td>level == LogLevel.Warn</td>
            <td>Magenta</td>
            <td>NoChange</td>
            </tr>
            <tr>
            <td>level == LogLevel.Info</td>
            <td>White</td>
            <td>NoChange</td>
            </tr>
            <tr>
            <td>level == LogLevel.Debug</td>
            <td>Gray</td>
            <td>NoChange</td>
            </tr>
            <tr>
            <td>level == LogLevel.Trace</td>
            <td>DarkGray</td>
            <td>NoChange</td>
            </tr>
            </table>
            </remarks>
            <docgen category='Highlighting Rules' order='9' />
        </member>
        <member name="P:NLog.Targets.ColoredConsoleTarget.Encoding">
            <summary>
            The encoding for writing messages to the <see cref="T:System.Console"/>.
             </summary>
            <remarks>Has side effect</remarks>
            <docgen category='Console Options' order='10' />
        </member>
        <member name="P:NLog.Targets.ColoredConsoleTarget.DetectConsoleAvailable">
            <summary>
            Gets or sets a value indicating whether to auto-check if the console is available.
             - Disables console writing if Environment.UserInteractive = False (Windows Service)
             - Disables console writing if Console Standard Input is not available (Non-Console-App)
            </summary>
            <docgen category='Console Options' order='10' />
        </member>
        <member name="P:NLog.Targets.ColoredConsoleTarget.DetectOutputRedirected">
            <summary>
            Gets or sets a value indicating whether to auto-check if the console has been redirected to file
              - Disables coloring logic when System.Console.IsOutputRedirected = true
            </summary>
            <docgen category='Console Options' order='11' />
        </member>
        <member name="P:NLog.Targets.ColoredConsoleTarget.AutoFlush">
            <summary>
            Gets or sets a value indicating whether to auto-flush after <see cref="M:System.Console.WriteLine"/>
            </summary>
            <remarks>
            Normally not required as standard Console.Out will have <see cref="P:System.IO.StreamWriter.AutoFlush"/> = true, but not when pipe to file
            </remarks>
            <docgen category='Console Options' order='11' />
        </member>
        <member name="P:NLog.Targets.ColoredConsoleTarget.EnableAnsiOutput">
            <summary>
            Enables output using ANSI Color Codes
            </summary>
            <docgen category='Console Options' order='10' />
        </member>
        <member name="P:NLog.Targets.ColoredConsoleTarget.NoColor">
            <summary>
            Support NO_COLOR=1 environment variable. See also <see href="https://no-color.org/" />
            </summary>
        </member>
        <member name="P:NLog.Targets.ColoredConsoleTarget.RowHighlightingRules">
            <summary>
            Gets the row highlighting rules.
            </summary>
            <docgen category='Highlighting Rules' order='10' />
        </member>
        <member name="P:NLog.Targets.ColoredConsoleTarget.WordHighlightingRules">
            <summary>
            Gets the word highlighting rules.
            </summary>
            <docgen category='Highlighting Rules' order='11' />
        </member>
        <member name="M:NLog.Targets.ColoredConsoleTarget.InitializeTarget">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Targets.ColoredConsoleTarget.CloseTarget">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Targets.ColoredConsoleTarget.FlushAsync(NLog.Common.AsyncContinuation)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Targets.ColoredConsoleTarget.Write(NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.Targets.ConsoleOutputColor">
            <summary>
            Colored console output color.
            </summary>
            <remarks>
            Note that this enumeration is defined to be binary compatible with
            .NET 2.0 System.ConsoleColor + some additions
            </remarks>
        </member>
        <member name="F:NLog.Targets.ConsoleOutputColor.Black">
            <summary>
            Black Color (#000000).
            </summary>
        </member>
        <member name="F:NLog.Targets.ConsoleOutputColor.DarkBlue">
            <summary>
            Dark blue Color (#000080).
            </summary>
        </member>
        <member name="F:NLog.Targets.ConsoleOutputColor.DarkGreen">
            <summary>
            Dark green Color (#008000).
            </summary>
        </member>
        <member name="F:NLog.Targets.ConsoleOutputColor.DarkCyan">
            <summary>
            Dark Cyan Color (#008080).
            </summary>
        </member>
        <member name="F:NLog.Targets.ConsoleOutputColor.DarkRed">
            <summary>
            Dark Red Color (#800000).
            </summary>
        </member>
        <member name="F:NLog.Targets.ConsoleOutputColor.DarkMagenta">
            <summary>
            Dark Magenta Color (#800080).
            </summary>
        </member>
        <member name="F:NLog.Targets.ConsoleOutputColor.DarkYellow">
            <summary>
            Dark Yellow Color (#808000).
            </summary>
        </member>
        <member name="F:NLog.Targets.ConsoleOutputColor.Gray">
            <summary>
            Gray Color (#C0C0C0).
            </summary>
        </member>
        <member name="F:NLog.Targets.ConsoleOutputColor.DarkGray">
            <summary>
            Dark Gray Color (#808080).
            </summary>
        </member>
        <member name="F:NLog.Targets.ConsoleOutputColor.Blue">
            <summary>
            Blue Color (#0000FF).
            </summary>
        </member>
        <member name="F:NLog.Targets.ConsoleOutputColor.Green">
            <summary>
            Green Color (#00FF00).
            </summary>
        </member>
        <member name="F:NLog.Targets.ConsoleOutputColor.Cyan">
            <summary>
            Cyan Color (#00FFFF).
            </summary>
        </member>
        <member name="F:NLog.Targets.ConsoleOutputColor.Red">
            <summary>
            Red Color (#FF0000).
            </summary>
        </member>
        <member name="F:NLog.Targets.ConsoleOutputColor.Magenta">
            <summary>
            Magenta Color (#FF00FF).
            </summary>
        </member>
        <member name="F:NLog.Targets.ConsoleOutputColor.Yellow">
            <summary>
            Yellow Color (#FFFF00).
            </summary>
        </member>
        <member name="F:NLog.Targets.ConsoleOutputColor.White">
            <summary>
            White Color (#FFFFFF).
            </summary>
        </member>
        <member name="F:NLog.Targets.ConsoleOutputColor.NoChange">
            <summary>
            Don't change the color.
            </summary>
        </member>
        <member name="T:NLog.Targets.ConsoleRowHighlightingRule">
            <summary>
            The row-highlighting condition.
            </summary>
        </member>
        <member name="M:NLog.Targets.ConsoleRowHighlightingRule.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.ConsoleRowHighlightingRule" /> class.
            </summary>
        </member>
        <member name="M:NLog.Targets.ConsoleRowHighlightingRule.#ctor(NLog.Conditions.ConditionExpression,NLog.Targets.ConsoleOutputColor,NLog.Targets.ConsoleOutputColor)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.ConsoleRowHighlightingRule" /> class.
            </summary>
            <param name="condition">The condition.</param>
            <param name="foregroundColor">Color of the foreground.</param>
            <param name="backgroundColor">Color of the background.</param>
        </member>
        <member name="P:NLog.Targets.ConsoleRowHighlightingRule.Default">
            <summary>
            Gets the default highlighting rule. Doesn't change the color.
            </summary>
        </member>
        <member name="P:NLog.Targets.ConsoleRowHighlightingRule.Condition">
            <summary>
            Gets or sets the condition that must be met in order to set the specified foreground and background color.
            </summary>
            <docgen category='Highlighting Rules' order='10' />
        </member>
        <member name="P:NLog.Targets.ConsoleRowHighlightingRule.ForegroundColor">
            <summary>
            Gets or sets the foreground color.
            </summary>
            <docgen category='Highlighting Rules' order='10' />
        </member>
        <member name="P:NLog.Targets.ConsoleRowHighlightingRule.BackgroundColor">
            <summary>
            Gets or sets the background color.
            </summary>
            <docgen category='Highlighting Rules' order='10' />
        </member>
        <member name="M:NLog.Targets.ConsoleRowHighlightingRule.CheckCondition(NLog.LogEventInfo)">
            <summary>
            Checks whether the specified log event matches the condition (if any).
            </summary>
            <param name="logEvent">
            Log event.
            </param>
            <returns>
            A value of <see langword="true"/> if the condition is not defined or
            if it matches, <see langword="false"/> otherwise.
            </returns>
        </member>
        <member name="T:NLog.Targets.ConsoleTarget">
            <summary>
            Writes log messages to the console.
            </summary>
            <remarks>
            <a href="https://github.com/nlog/nlog/wiki/Console-target">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/nlog/nlog/wiki/Console-target">Documentation on NLog Wiki</seealso>
            <example>
            <p>
            To set up the target in the <a href="https://github.com/NLog/NLog/wiki/Configuration-file">configuration file</a>,
            use the following syntax:
            </p>
            <code lang="XML" source="examples/targets/Configuration File/Console/NLog.config" />
            <p>
            To set up the log target programmatically use code like this:
            </p>
            <code lang="C#" source="examples/targets/Configuration API/Console/Simple/Example.cs" />
            </example>
        </member>
        <member name="F:NLog.Targets.ConsoleTarget._pauseLogging">
             <summary>
             Should logging being paused/stopped because of the race condition bug in Console.Writeline?
             </summary>
             <remarks>
               Console.Out.Writeline / Console.Error.Writeline could throw 'IndexOutOfRangeException', which is a bug.
             See https://stackoverflow.com/questions/33915790/console-out-and-console-error-race-condition-error-in-a-windows-service-written
             and https://connect.microsoft.com/VisualStudio/feedback/details/2057284/console-out-probable-i-o-race-condition-issue-in-multi-threaded-windows-service
            
             Full error:
               Error during session close: System.IndexOutOfRangeException: Probable I/ O race condition detected while copying memory.
               The I/ O package is not thread safe by default. In multi-threaded applications,
               a stream must be accessed in a thread-safe way, such as a thread - safe wrapper returned by TextReader's or
               TextWriter's Synchronized methods.This also applies to classes like StreamWriter and StreamReader.
            
             </remarks>
        </member>
        <member name="P:NLog.Targets.ConsoleTarget.Error">
            <summary>
            Obsolete and replaced by <see cref="P:NLog.Targets.ConsoleTarget.StdErr"/> with NLog v5.
            Gets or sets a value indicating whether to send the log messages to the standard error instead of the standard output.
            </summary>
            <docgen category='Console Options' order='10' />
        </member>
        <member name="P:NLog.Targets.ConsoleTarget.StdErr">
            <summary>
            Gets or sets a value indicating whether to send the log messages to the standard error instead of the standard output.
            </summary>
            <docgen category='Console Options' order='10' />
        </member>
        <member name="P:NLog.Targets.ConsoleTarget.Encoding">
            <summary>
            The encoding for writing messages to the <see cref="T:System.Console"/>.
            </summary>
            <remarks>Has side effect</remarks>
            <docgen category='Console Options' order='10' />
        </member>
        <member name="P:NLog.Targets.ConsoleTarget.DetectConsoleAvailable">
            <summary>
            Gets or sets a value indicating whether to auto-check if the console is available
             - Disables console writing if Environment.UserInteractive = False (Windows Service)
             - Disables console writing if Console Standard Input is not available (Non-Console-App)
            </summary>
            <docgen category='Console Options' order='10' />
        </member>
        <member name="P:NLog.Targets.ConsoleTarget.AutoFlush">
            <summary>
            Gets or sets a value indicating whether to auto-flush after <see cref="M:System.Console.WriteLine"/>
            </summary>
            <remarks>
            Normally not required as standard Console.Out will have <see cref="P:System.IO.StreamWriter.AutoFlush"/> = true, but not when pipe to file
            </remarks>
            <docgen category='Console Options' order='10' />
        </member>
        <member name="P:NLog.Targets.ConsoleTarget.WriteBuffer">
            <summary>
            Gets or sets whether to activate internal buffering to allow batch writing, instead of using <see cref="M:System.Console.WriteLine"/>
            </summary>
            <docgen category='Console Options' order='10' />
        </member>
        <member name="M:NLog.Targets.ConsoleTarget.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.ConsoleTarget" /> class.
            </summary>
            <remarks>
            The default value of the layout is: <code>${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}</code>
            </remarks>
        </member>
        <member name="M:NLog.Targets.ConsoleTarget.#ctor(System.String)">
             <summary>
            
             Initializes a new instance of the <see cref="T:NLog.Targets.ConsoleTarget" /> class.
             </summary>
             <remarks>
             The default value of the layout is: <code>${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}</code>
             </remarks>
             <param name="name">Name of the target.</param>
        </member>
        <member name="M:NLog.Targets.ConsoleTarget.InitializeTarget">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Targets.ConsoleTarget.CloseTarget">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Targets.ConsoleTarget.FlushAsync(NLog.Common.AsyncContinuation)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Targets.ConsoleTarget.Write(NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Targets.ConsoleTarget.Write(System.Collections.Generic.IList{NLog.Common.AsyncLogEventInfo})">
            <inheritdoc/>
        </member>
        <member name="T:NLog.Targets.ConsoleWordHighlightingRule">
            <summary>
            Highlighting rule for Win32 colorful console.
            </summary>
        </member>
        <member name="M:NLog.Targets.ConsoleWordHighlightingRule.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.ConsoleWordHighlightingRule" /> class.
            </summary>
        </member>
        <member name="M:NLog.Targets.ConsoleWordHighlightingRule.#ctor(System.String,NLog.Targets.ConsoleOutputColor,NLog.Targets.ConsoleOutputColor)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.ConsoleWordHighlightingRule" /> class.
            </summary>
            <param name="text">The text to be matched..</param>
            <param name="foregroundColor">Color of the foreground.</param>
            <param name="backgroundColor">Color of the background.</param>
        </member>
        <member name="P:NLog.Targets.ConsoleWordHighlightingRule.Regex">
            <summary>
            Gets or sets the regular expression to be matched. You must specify either <c>text</c> or <c>regex</c>.
            </summary>
            <docgen category='Highlighting Rules' order='10' />
        </member>
        <member name="P:NLog.Targets.ConsoleWordHighlightingRule.Condition">
            <summary>
            Gets or sets the condition that must be met before scanning the row for highlight of words
            </summary>
            <docgen category='Highlighting Rules' order='10' />
        </member>
        <member name="P:NLog.Targets.ConsoleWordHighlightingRule.CompileRegex">
            <summary>
            Compile the <see cref="P:NLog.Targets.ConsoleWordHighlightingRule.Regex"/>? This can improve the performance, but at the costs of more memory usage. If <c>false</c>, the Regex Cache is used.
            </summary>
            <docgen category='Highlighting Rules' order='10' />
        </member>
        <member name="P:NLog.Targets.ConsoleWordHighlightingRule.Text">
            <summary>
            Gets or sets the text to be matched. You must specify either <c>text</c> or <c>regex</c>.
            </summary>
            <docgen category='Highlighting Rules' order='10' />
        </member>
        <member name="P:NLog.Targets.ConsoleWordHighlightingRule.WholeWords">
            <summary>
            Gets or sets a value indicating whether to match whole words only.
            </summary>
            <docgen category='Highlighting Rules' order='10' />
        </member>
        <member name="P:NLog.Targets.ConsoleWordHighlightingRule.IgnoreCase">
            <summary>
            Gets or sets a value indicating whether to ignore case when comparing texts.
            </summary>
            <docgen category='Highlighting Rules' order='10' />
        </member>
        <member name="P:NLog.Targets.ConsoleWordHighlightingRule.ForegroundColor">
            <summary>
            Gets or sets the foreground color.
            </summary>
            <docgen category='Highlighting Rules' order='10' />
        </member>
        <member name="P:NLog.Targets.ConsoleWordHighlightingRule.BackgroundColor">
            <summary>
            Gets or sets the background color.
            </summary>
            <docgen category='Highlighting Rules' order='10' />
        </member>
        <member name="P:NLog.Targets.ConsoleWordHighlightingRule.CompiledRegex">
            <summary>
            Gets the compiled regular expression that matches either Text or Regex property. Only used when <see cref="P:NLog.Targets.ConsoleWordHighlightingRule.CompileRegex"/> is <c>true</c>.
            </summary>
        </member>
        <member name="T:NLog.Targets.DateAndSequenceArchive">
            <summary>
            A descriptor for an archive created with the DateAndSequence numbering mode.
            </summary>
        </member>
        <member name="P:NLog.Targets.DateAndSequenceArchive.FileName">
            <summary>
            The full name of the archive file.
            </summary>
        </member>
        <member name="P:NLog.Targets.DateAndSequenceArchive.Date">
            <summary>
            The parsed date contained in the file name.
            </summary>
        </member>
        <member name="P:NLog.Targets.DateAndSequenceArchive.Sequence">
            <summary>
            The parsed sequence number contained in the file name.
            </summary>
        </member>
        <member name="M:NLog.Targets.DateAndSequenceArchive.HasSameFormattedDate(System.DateTime)">
            <summary>
            Determines whether <paramref name="date"/> produces the same string as the current instance's date once formatted with the current instance's date format.
            </summary>
            <param name="date">The date to compare the current object's date to.</param>
            <returns><c>True</c> if the formatted dates are equal, otherwise <c>False</c>.</returns>
        </member>
        <member name="M:NLog.Targets.DateAndSequenceArchive.#ctor(System.String,System.DateTime,System.String,System.Int32)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.DateAndSequenceArchive"/> class.
            </summary>
        </member>
        <member name="T:NLog.Targets.DebuggerTarget">
            <summary>
            Writes log messages to the attached managed debugger.
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/Debugger-target">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/Debugger-target">Documentation on NLog Wiki</seealso>
            <example>
            <p>
            To set up the target in the <a href="https://github.com/NLog/NLog/wiki/Configuration-file">configuration file</a>,
            use the following syntax:
            </p>
            <code lang="XML" source="examples/targets/Configuration File/Debugger/NLog.config" />
            <p>
            To set up the log target programmatically use code like this:
            </p>
            <code lang="C#" source="examples/targets/Configuration API/Debugger/Simple/Example.cs" />
            </example>
        </member>
        <member name="M:NLog.Targets.DebuggerTarget.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.DebuggerTarget" /> class.
            </summary>
            <remarks>
            The default value of the layout is: <code>${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}</code>
            </remarks>
        </member>
        <member name="M:NLog.Targets.DebuggerTarget.#ctor(System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.DebuggerTarget" /> class.
            </summary>
            <remarks>
            The default value of the layout is: <code>${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}</code>
            </remarks>
            <param name="name">Name of the target.</param>
        </member>
        <member name="M:NLog.Targets.DebuggerTarget.InitializeTarget">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Targets.DebuggerTarget.CloseTarget">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Targets.DebuggerTarget.Write(NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.Targets.DebugSystemTarget">
            <summary>
            Outputs log messages through <see cref="M:System.Diagnostics.Debug.WriteLine(System.String)" />
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/DebugSystem-target">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/DebugSystem-target">Documentation on NLog Wiki</seealso>
        </member>
        <member name="M:NLog.Targets.DebugSystemTarget.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.DebugSystemTarget" /> class.
            </summary>
            <remarks>
            The default value of the layout is: <code>${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}</code>
            </remarks>
        </member>
        <member name="M:NLog.Targets.DebugSystemTarget.#ctor(System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.DebugSystemTarget" /> class.
            </summary>
            <remarks>
            The default value of the layout is: <code>${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}</code>
            </remarks>
            <param name="name">Name of the target.</param>
        </member>
        <member name="M:NLog.Targets.DebugSystemTarget.InitializeTarget">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Targets.DebugSystemTarget.CloseTarget">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Targets.DebugSystemTarget.Write(NLog.LogEventInfo)">
            <summary>
            Outputs the rendered logging event through <see cref="M:System.Diagnostics.Debug.WriteLine(System.String)" />
            </summary>
            <param name="logEvent">The logging event.</param>
        </member>
        <member name="T:NLog.Targets.DebugTarget">
            <summary>
            Mock target - useful for testing.
            </summary>
            <remarks>
            <a href="https://github.com/nlog/nlog/wiki/Debug-target">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/nlog/nlog/wiki/Debug-target">Documentation on NLog Wiki</seealso>
            <example>
            <p>
            To set up the target in the <a href="https://github.com/NLog/NLog/wiki/Configuration-file">configuration file</a>,
            use the following syntax:
            </p>
            <code lang="XML" source="examples/targets/Configuration File/Debug/NLog.config" />
            <p>
            To set up the log target programmatically use code like this:
            </p>
            <code lang="C#" source="examples/targets/Configuration API/Debug/Simple/Example.cs" />
            </example>
        </member>
        <member name="M:NLog.Targets.DebugTarget.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.DebugTarget" /> class.
            </summary>
            <remarks>
            The default value of the layout is: <code>${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}</code>
            </remarks>
        </member>
        <member name="M:NLog.Targets.DebugTarget.#ctor(System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.DebugTarget" /> class.
            </summary>
            <remarks>
            The default value of the layout is: <code>${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}</code>
            </remarks>
            <param name="name">Name of the target.</param>
        </member>
        <member name="P:NLog.Targets.DebugTarget.Counter">
            <summary>
            Gets the number of times this target has been called.
            </summary>
            <docgen category='Debugging Options' order='10' />
        </member>
        <member name="P:NLog.Targets.DebugTarget.LastMessage">
            <summary>
            Gets the last message rendered by this target.
            </summary>
            <docgen category='Debugging Options' order='10' />
        </member>
        <member name="M:NLog.Targets.DebugTarget.Write(NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.Targets.DefaultJsonSerializer">
            <summary>
            Default class for serialization of values to JSON format.
            </summary>
        </member>
        <member name="P:NLog.Targets.DefaultJsonSerializer.Instance">
            <summary>
            Singleton instance of the serializer.
            </summary>
        </member>
        <member name="M:NLog.Targets.DefaultJsonSerializer.#ctor(System.IServiceProvider)">
            <summary>
            Private. Use <see cref="P:NLog.Targets.DefaultJsonSerializer.Instance"/>
            </summary>
        </member>
        <member name="M:NLog.Targets.DefaultJsonSerializer.SerializeObject(System.Object)">
            <summary>
            Returns a serialization of an object into JSON format.
            </summary>
            <param name="value">The object to serialize to JSON.</param>
            <returns>Serialized value.</returns>
        </member>
        <member name="M:NLog.Targets.DefaultJsonSerializer.SerializeObject(System.Object,NLog.Targets.JsonSerializeOptions)">
            <summary>
            Returns a serialization of an object into JSON format.
            </summary>
            <param name="value">The object to serialize to JSON.</param>
            <param name="options">serialization options</param>
            <returns>Serialized value.</returns>
        </member>
        <member name="M:NLog.Targets.DefaultJsonSerializer.SerializeObject(System.Object,System.Text.StringBuilder)">
            <summary>
            Serialization of the object in JSON format to the destination StringBuilder
            </summary>
            <param name="value">The object to serialize to JSON.</param>
            <param name="destination">Write the resulting JSON to this destination.</param>
            <returns>Object serialized successfully (true/false).</returns>
        </member>
        <member name="M:NLog.Targets.DefaultJsonSerializer.SerializeObject(System.Object,System.Text.StringBuilder,NLog.Targets.JsonSerializeOptions)">
            <summary>
            Serialization of the object in JSON format to the destination StringBuilder
            </summary>
            <param name="value">The object to serialize to JSON.</param>
            <param name="destination">Write the resulting JSON to this destination.</param>
            <param name="options">serialization options</param>
            <returns>Object serialized successfully (true/false).</returns>
        </member>
        <member name="M:NLog.Targets.DefaultJsonSerializer.SerializeObject(System.Object,System.Text.StringBuilder,NLog.Targets.JsonSerializeOptions,NLog.Internal.SingleItemOptimizedHashSet{System.Object},System.Int32)">
            <summary>
            Serialization of the object in JSON format to the destination StringBuilder
            </summary>
            <param name="value">The object to serialize to JSON.</param>
            <param name="destination">Write the resulting JSON to this destination.</param>
            <param name="options">serialization options</param>
            <param name="objectsInPath">The objects in path (Avoid cyclic reference loop).</param>
            <param name="depth">The current depth (level) of recursion.</param>
            <returns>Object serialized successfully (true/false).</returns>
        </member>
        <member name="M:NLog.Targets.DefaultJsonSerializer.SkipQuotes(System.IConvertible,System.TypeCode)">
            <summary>
            No quotes needed for this type?
            </summary>
        </member>
        <member name="M:NLog.Targets.DefaultJsonSerializer.IsNumericTypeCode(System.TypeCode,System.Boolean)">
            <summary>
            Checks the object <see cref="T:System.TypeCode" /> if it is numeric
            </summary>
            <param name="objTypeCode">TypeCode for the object</param>
            <param name="includeDecimals">Accept fractional types as numeric type.</param>
            <returns></returns>
        </member>
        <member name="M:NLog.Targets.DefaultJsonSerializer.AppendStringEscape(System.Text.StringBuilder,System.String,NLog.Targets.JsonSerializeOptions)">
            <summary>
            Checks input string if it needs JSON escaping, and makes necessary conversion
            </summary>
            <param name="destination">Destination Builder</param>
            <param name="text">Input string</param>
            <param name="options">all options</param>
            <returns>JSON escaped string</returns>
        </member>
        <member name="M:NLog.Targets.DefaultJsonSerializer.AppendStringEscape(System.Text.StringBuilder,System.String,System.Boolean,System.Boolean)">
            <summary>
            Checks input string if it needs JSON escaping, and makes necessary conversion
            </summary>
            <param name="destination">Destination Builder</param>
            <param name="text">Input string</param>
            <param name="escapeUnicode">Should non-ASCII characters be encoded</param>
            <param name="escapeForwardSlash"></param>
            <returns>JSON escaped string</returns>
        </member>
        <member name="T:NLog.Targets.EventLogTarget">
            <summary>
            Writes log message to the Event Log.
            </summary>
            <remarks>
            <a href="https://github.com/nlog/nlog/wiki/EventLog-target">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/nlog/nlog/wiki/EventLog-target">Documentation on NLog Wiki</seealso>
            <example>
            <p>
            To set up the target in the <a href="https://github.com/NLog/NLog/wiki/Configuration-file">configuration file</a>,
            use the following syntax:
            </p>
            <code lang="XML" source="examples/targets/Configuration File/EventLog/NLog.config" />
            <p>
            To set up the log target programmatically use code like this:
            </p>
            <code lang="C#" source="examples/targets/Configuration API/EventLog/Simple/Example.cs" />
            </example>
        </member>
        <member name="F:NLog.Targets.EventLogTarget.EventLogMaxMessageLength">
            <summary>
            Max size in characters (limitation of the EventLog API).
            </summary>
            <seealso href="https://docs.microsoft.com/en-gb/windows/win32/api/winbase/nf-winbase-reporteventw"/>
        </member>
        <member name="M:NLog.Targets.EventLogTarget.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.EventLogTarget"/> class.
            </summary>
        </member>
        <member name="M:NLog.Targets.EventLogTarget.#ctor(System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.EventLogTarget"/> class.
            </summary>
            <param name="name">Name of the target.</param>
        </member>
        <member name="M:NLog.Targets.EventLogTarget.#ctor(NLog.Targets.EventLogTarget.IEventLogWrapper,System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.EventLogTarget"/> class.
            </summary>
        </member>
        <member name="P:NLog.Targets.EventLogTarget.MachineName">
            <summary>
            Gets or sets the name of the machine on which Event Log service is running.
            </summary>
            <docgen category='Event Log Options' order='10' />
        </member>
        <member name="P:NLog.Targets.EventLogTarget.EventId">
            <summary>
            Gets or sets the layout that renders event ID.
            </summary>
            <docgen category='Event Log Options' order='10' />
        </member>
        <member name="P:NLog.Targets.EventLogTarget.Category">
            <summary>
            Gets or sets the layout that renders event Category.
            </summary>
            <docgen category='Event Log Options' order='10' />
        </member>
        <member name="P:NLog.Targets.EventLogTarget.EntryType">
            <summary>
            Optional entry type. When not set, or when not convertible to <see cref="T:System.Diagnostics.EventLogEntryType"/> then determined by <see cref="T:NLog.LogLevel"/>
            </summary>
            <docgen category='Event Log Options' order='10' />
        </member>
        <member name="P:NLog.Targets.EventLogTarget.Source">
            <summary>
            Gets or sets the value to be used as the event Source.
            </summary>
            <remarks>
            By default this is the friendly name of the current AppDomain.
            </remarks>
            <docgen category='Event Log Options' order='10' />
        </member>
        <member name="P:NLog.Targets.EventLogTarget.Log">
            <summary>
            Gets or sets the name of the Event Log to write to. This can be System, Application or any user-defined name.
            </summary>
            <docgen category='Event Log Options' order='10' />
        </member>
        <member name="P:NLog.Targets.EventLogTarget.MaxMessageLength">
            <summary>
            Gets or sets the message length limit to write to the Event Log.
            </summary>
            <remarks><value>MaxMessageLength</value> cannot be zero or negative</remarks>
            <docgen category='Event Log Options' order='10' />
        </member>
        <member name="P:NLog.Targets.EventLogTarget.MaxKilobytes">
            <summary>
            Gets or sets the maximum Event log size in kilobytes.
            </summary>
            <remarks>
            <value>MaxKilobytes</value> cannot be less than 64 or greater than 4194240 or not a multiple of 64.
            If <c>null</c>, the value will not be specified while creating the Event log.
            </remarks>
            <docgen category='Event Log Options' order='10' />
        </member>
        <member name="P:NLog.Targets.EventLogTarget.OnOverflow">
            <summary>
            Gets or sets the action to take if the message is larger than the <see cref="P:NLog.Targets.EventLogTarget.MaxMessageLength"/> option.
            </summary>
            <docgen category='Event Log Options' order='100' />
        </member>
        <member name="M:NLog.Targets.EventLogTarget.Install(NLog.Config.InstallationContext)">
            <summary>
            Performs installation which requires administrative permissions.
            </summary>
            <param name="installationContext">The installation context.</param>
        </member>
        <member name="M:NLog.Targets.EventLogTarget.Uninstall(NLog.Config.InstallationContext)">
            <summary>
            Performs uninstallation which requires administrative permissions.
            </summary>
            <param name="installationContext">The installation context.</param>
        </member>
        <member name="M:NLog.Targets.EventLogTarget.IsInstalled(NLog.Config.InstallationContext)">
            <summary>
            Determines whether the item is installed.
            </summary>
            <param name="installationContext">The installation context.</param>
            <returns>
            Value indicating whether the item is installed or null if it is not possible to determine.
            </returns>
        </member>
        <member name="M:NLog.Targets.EventLogTarget.InitializeTarget">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Targets.EventLogTarget.Write(NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Targets.EventLogTarget.GetEntryType(NLog.LogEventInfo)">
            <summary>
            Get the entry type for logging the message.
            </summary>
            <param name="logEvent">The logging event - for rendering the <see cref="P:NLog.Targets.EventLogTarget.EntryType"/></param>
        </member>
        <member name="M:NLog.Targets.EventLogTarget.GetFixedSource">
            <summary>
            Get the source, if and only if the source is fixed.
            </summary>
            <returns><c>null</c> when not <see cref="P:NLog.Layouts.SimpleLayout.IsFixedText"/></returns>
            <remarks>Internal for unit tests</remarks>
        </member>
        <member name="M:NLog.Targets.EventLogTarget.CreateEventSourceIfNeeded(System.String,System.Boolean)">
            <summary>
            (re-)create an event source, if it isn't there. Works only with fixed source names.
            </summary>
            <param name="fixedSource">The source name. If source is not fixed (see <see cref="P:NLog.Layouts.SimpleLayout.IsFixedText"/>, then pass <c>null</c> or <see cref="F:System.String.Empty"/>.</param>
            <param name="alwaysThrowError">always throw an Exception when there is an error</param>
        </member>
        <member name="T:NLog.Targets.EventLogTarget.IEventLogWrapper">
            <summary>
            A wrapper for Windows event log.
            </summary>
        </member>
        <member name="P:NLog.Targets.EventLogTarget.IEventLogWrapper.Source">
            <summary>
            A wrapper for the property <see cref="P:System.Diagnostics.EventLog.Source"/>.
            </summary>
        </member>
        <member name="P:NLog.Targets.EventLogTarget.IEventLogWrapper.Log">
            <summary>
            A wrapper for the property <see cref="P:System.Diagnostics.EventLog.Log"/>.
            </summary>
        </member>
        <member name="P:NLog.Targets.EventLogTarget.IEventLogWrapper.MachineName">
            <summary>
            A wrapper for the property <see cref="P:System.Diagnostics.EventLog.MachineName"/>.
            </summary>
        </member>
        <member name="P:NLog.Targets.EventLogTarget.IEventLogWrapper.MaximumKilobytes">
            <summary>
            A wrapper for the property <see cref="P:System.Diagnostics.EventLog.MaximumKilobytes"/>.
            </summary>
        </member>
        <member name="P:NLog.Targets.EventLogTarget.IEventLogWrapper.IsEventLogAssociated">
            <summary>
            Indicates whether an event log instance is associated.
            </summary>
        </member>
        <member name="M:NLog.Targets.EventLogTarget.IEventLogWrapper.WriteEntry(System.String,System.Diagnostics.EventLogEntryType,System.Int32,System.Int16)">
            <summary>
            A wrapper for the method <see cref="M:System.Diagnostics.EventLog.WriteEntry(System.String,System.Diagnostics.EventLogEntryType,System.Int32,System.Int16)"/>.
            </summary>
        </member>
        <member name="M:NLog.Targets.EventLogTarget.IEventLogWrapper.AssociateNewEventLog(System.String,System.String,System.String)">
            <summary>
            Creates a new association with an instance of the event log.
            </summary>
        </member>
        <member name="M:NLog.Targets.EventLogTarget.IEventLogWrapper.DeleteEventSource(System.String,System.String)">
            <summary>
            A wrapper for the static method <see cref="M:System.Diagnostics.EventLog.DeleteEventSource(System.String,System.String)"/>.
            </summary>
        </member>
        <member name="M:NLog.Targets.EventLogTarget.IEventLogWrapper.SourceExists(System.String,System.String)">
            <summary>
            A wrapper for the static method <see cref="M:System.Diagnostics.EventLog.SourceExists(System.String,System.String)"/>.
            </summary>
        </member>
        <member name="M:NLog.Targets.EventLogTarget.IEventLogWrapper.LogNameFromSourceName(System.String,System.String)">
            <summary>
            A wrapper for the static method <see cref="M:System.Diagnostics.EventLog.LogNameFromSourceName(System.String,System.String)"/>.
            </summary>
        </member>
        <member name="M:NLog.Targets.EventLogTarget.IEventLogWrapper.CreateEventSource(System.Diagnostics.EventSourceCreationData)">
            <summary>
            A wrapper for the static method <see cref="M:System.Diagnostics.EventLog.CreateEventSource(System.Diagnostics.EventSourceCreationData)"/>.
            </summary>
        </member>
        <member name="T:NLog.Targets.EventLogTarget.EventLogWrapper">
            <summary>
            The implementation of <see cref="T:NLog.Targets.EventLogTarget.IEventLogWrapper"/>, that uses Windows <see cref="T:System.Diagnostics.EventLog"/>.
            </summary>
        </member>
        <member name="M:NLog.Targets.EventLogTarget.EventLogWrapper.AssociateNewEventLog(System.String,System.String,System.String)">
            <summary>
            Creates a new association with an instance of Windows <see cref="T:System.Diagnostics.EventLog"/>.
            </summary>
        </member>
        <member name="T:NLog.Targets.EventLogTargetOverflowAction">
            <summary>
            Action that should be taken if the message is greater than
            the max message size allowed by the Event Log.
            </summary>
        </member>
        <member name="F:NLog.Targets.EventLogTargetOverflowAction.Truncate">
            <summary>
            Truncate the message before writing to the Event Log.
            </summary>
        </member>
        <member name="F:NLog.Targets.EventLogTargetOverflowAction.Split">
            <summary>
            Split the message and write multiple entries to the Event Log.
            </summary>
        </member>
        <member name="F:NLog.Targets.EventLogTargetOverflowAction.Discard">
            <summary>
            Discard of the message. It will not be written to the Event Log.
            </summary>
        </member>
        <member name="M:NLog.Targets.FileArchiveModes.FileArchiveModeBase.AttemptCleanupOnInitializeFile(System.String,System.Int32,System.Int32)">
             <summary>
             Check if cleanup should be performed on initialize new file
            
             Skip cleanup when initializing new file, just after having performed archive operation
             </summary>
             <param name="archiveFilePath">Base archive file pattern</param>
             <param name="maxArchiveFiles">Maximum number of archive files that should be kept</param>
             <param name="maxArchiveDays">Maximum days of archive files that should be kept</param>
             <returns>True, when archive cleanup is needed</returns>
        </member>
        <member name="F:NLog.Targets.FileArchiveModes.FileArchiveModeBase.FileNameTemplate.PatternStartCharacters">
            <summary>
            Characters determining the start of the <see cref="P:NLog.Targets.FileArchiveModes.FileArchiveModeBase.FileNameTemplate.Template"/>.
            </summary>
        </member>
        <member name="F:NLog.Targets.FileArchiveModes.FileArchiveModeBase.FileNameTemplate.PatternEndCharacters">
            <summary>
            Characters determining the end of the <see cref="P:NLog.Targets.FileArchiveModes.FileArchiveModeBase.FileNameTemplate.Template"/>.
            </summary>
        </member>
        <member name="P:NLog.Targets.FileArchiveModes.FileArchiveModeBase.FileNameTemplate.Template">
            <summary>
            File name which is used as template for matching and replacements.
            It is expected to contain a pattern to match.
            </summary>
        </member>
        <member name="P:NLog.Targets.FileArchiveModes.FileArchiveModeBase.FileNameTemplate.BeginAt">
            <summary>
            The beginning position of the <see cref="F:NLog.Targets.FileArchiveModes.FileArchiveModeBase.FileNameTemplate.PatternStartCharacters"/>
            within the <see cref="P:NLog.Targets.FileArchiveModes.FileArchiveModeBase.FileNameTemplate.Template"/>. -1 is returned
            when no pattern can be found.
            </summary>
        </member>
        <member name="P:NLog.Targets.FileArchiveModes.FileArchiveModeBase.FileNameTemplate.EndAt">
            <summary>
            The ending position of the <see cref="F:NLog.Targets.FileArchiveModes.FileArchiveModeBase.FileNameTemplate.PatternEndCharacters"/>
            within the <see cref="P:NLog.Targets.FileArchiveModes.FileArchiveModeBase.FileNameTemplate.Template"/>. -1 is returned
            when no pattern can be found.
            </summary>
        </member>
        <member name="M:NLog.Targets.FileArchiveModes.FileArchiveModeBase.FileNameTemplate.ReplacePattern(System.String)">
            <summary>
            Replace the pattern with the specified String.
            </summary>
            <param name="replacementValue"></param>
            <returns></returns>
        </member>
        <member name="T:NLog.Targets.FileArchiveModes.FileArchiveModeDate">
             <summary>
             Archives the log-files using a date style numbering. Archives will be stamped with the
             prior period (Year, Month, Day, Hour, Minute) datetime.
            
             When the number of archive files exceed <see cref="P:NLog.Targets.FileTarget.MaxArchiveFiles"/> the obsolete archives are deleted.
             When the age of archive files exceed <see cref="P:NLog.Targets.FileTarget.MaxArchiveDays"/> the obsolete archives are deleted.
             </summary>
        </member>
        <member name="T:NLog.Targets.FileArchiveModes.FileArchiveModeDateAndSequence">
             <summary>
             Archives the log-files using a date and sequence style numbering. Archives will be stamped
             with the prior period (Year, Month, Day) datetime. The most recent archive has the highest number (in
             combination with the date).
            
             When the number of archive files exceed <see cref="P:NLog.Targets.FileTarget.MaxArchiveFiles"/> the obsolete archives are deleted.
             When the age of archive files exceed <see cref="P:NLog.Targets.FileTarget.MaxArchiveDays"/> the obsolete archives are deleted.
             </summary>
        </member>
        <member name="M:NLog.Targets.FileArchiveModes.FileArchiveModeDateAndSequence.TryParseDateAndSequence(System.String,System.String,NLog.Targets.FileArchiveModes.FileArchiveModeBase.FileNameTemplate,System.DateTime@,System.Int32@)">
            <summary>
            Parse filename with date and sequence pattern
            </summary>
            <param name="archiveFileNameWithoutPath"></param>
            <param name="dateFormat">dateformat for archive</param>
            <param name="fileTemplate"></param>
            <param name="date">the found pattern. When failed, then default</param>
            <param name="sequence">the found pattern. When failed, then default</param>
            <returns></returns>
        </member>
        <member name="T:NLog.Targets.FileArchiveModes.FileArchiveModeDynamicSequence">
             <summary>
             Archives the log-files using the provided base-archive-filename. If the base-archive-filename causes
             duplicate archive filenames, then sequence-style is automatically enforced.
            
             Example:
                 Base Filename     trace.log
                 Next Filename     trace.0.log
            
             The most recent archive has the highest number.
            
             When the number of archive files exceed <see cref="P:NLog.Targets.FileTarget.MaxArchiveFiles"/> the obsolete archives are deleted.
             When the age of archive files exceed <see cref="P:NLog.Targets.FileTarget.MaxArchiveDays"/> the obsolete archives are deleted.
             </summary>
        </member>
        <member name="T:NLog.Targets.FileArchiveModes.FileArchiveModeDynamicTemplate">
            <summary>
            Dynamically converts a non-template archiveFilePath into a correct archiveFilePattern.
            Before called the original IFileArchiveMode, that has been wrapped by this
            </summary>
        </member>
        <member name="M:NLog.Targets.FileArchiveModes.FileArchiveModeFactory.ContainsFileNamePattern(System.String)">
             <summary>
             Determines if the file name as <see cref="T:System.String"/> contains a numeric pattern i.e. {#} in it.
            
             Example:
                 trace{#}.log        Contains the numeric pattern.
                 trace{###}.log      Contains the numeric pattern.
                 trace{#X#}.log      Contains the numeric pattern (See remarks).
                 trace.log           Does not contain the pattern.
             </summary>
             <remarks>Occasionally, this method can identify the existence of the {#} pattern incorrectly.</remarks>
             <param name="fileName">File name to be checked.</param>
             <returns><see langword="true"/> when the pattern is found; <see langword="false"/> otherwise.</returns>
        </member>
        <member name="T:NLog.Targets.FileArchiveModes.FileArchiveModeRolling">
             <summary>
             Archives the log-files using a rolling style numbering (the most recent is always #0 then
             #1, ..., #N.
            
             When the number of archive files exceed <see cref="P:NLog.Targets.FileTarget.MaxArchiveFiles"/> the obsolete archives
             are deleted.
             </summary>
        </member>
        <member name="M:NLog.Targets.FileArchiveModes.FileArchiveModeRolling.ReplaceNumberPattern(System.String,System.Int32)">
            <summary>
            Replaces the numeric pattern i.e. {#} in a file name with the <paramref name="value"/> parameter value.
            </summary>
            <param name="pattern">File name which contains the numeric pattern.</param>
            <param name="value">Value which will replace the numeric pattern.</param>
            <returns>File name with the value of <paramref name="value"/> in the position of the numeric pattern.</returns>
        </member>
        <member name="T:NLog.Targets.FileArchiveModes.FileArchiveModeSequence">
             <summary>
             Archives the log-files using a sequence style numbering. The most recent archive has the highest number.
            
             When the number of archive files exceed <see cref="P:NLog.Targets.FileTarget.MaxArchiveFiles"/> the obsolete archives are deleted.
             When the age of archive files exceed <see cref="P:NLog.Targets.FileTarget.MaxArchiveDays"/> the obsolete archives are deleted.
             </summary>
        </member>
        <member name="T:NLog.Targets.FileArchivePeriod">
            <summary>
            Modes of archiving files based on time.
            </summary>
        </member>
        <member name="F:NLog.Targets.FileArchivePeriod.None">
            <summary>
            Don't archive based on time.
            </summary>
        </member>
        <member name="F:NLog.Targets.FileArchivePeriod.Year">
            <summary>
            AddToArchive every year.
            </summary>
        </member>
        <member name="F:NLog.Targets.FileArchivePeriod.Month">
            <summary>
            AddToArchive every month.
            </summary>
        </member>
        <member name="F:NLog.Targets.FileArchivePeriod.Day">
            <summary>
            AddToArchive daily.
            </summary>
        </member>
        <member name="F:NLog.Targets.FileArchivePeriod.Hour">
            <summary>
            AddToArchive every hour.
            </summary>
        </member>
        <member name="F:NLog.Targets.FileArchivePeriod.Minute">
            <summary>
            AddToArchive every minute.
            </summary>
        </member>
        <member name="F:NLog.Targets.FileArchivePeriod.Sunday">
            <summary>
            AddToArchive every Sunday.
            </summary>
        </member>
        <member name="F:NLog.Targets.FileArchivePeriod.Monday">
            <summary>
            AddToArchive every Monday.
            </summary>
        </member>
        <member name="F:NLog.Targets.FileArchivePeriod.Tuesday">
            <summary>
            AddToArchive every Tuesday.
            </summary>
        </member>
        <member name="F:NLog.Targets.FileArchivePeriod.Wednesday">
            <summary>
            AddToArchive every Wednesday.
            </summary>
        </member>
        <member name="F:NLog.Targets.FileArchivePeriod.Thursday">
            <summary>
            AddToArchive every Thursday.
            </summary>
        </member>
        <member name="F:NLog.Targets.FileArchivePeriod.Friday">
            <summary>
            AddToArchive every Friday.
            </summary>
        </member>
        <member name="F:NLog.Targets.FileArchivePeriod.Saturday">
            <summary>
            AddToArchive every Saturday.
            </summary>
        </member>
        <member name="T:NLog.Targets.FilePathKind">
            <summary>
            Type of filepath
            </summary>
        </member>
        <member name="F:NLog.Targets.FilePathKind.Unknown">
            <summary>
            Detect of relative or absolute
            </summary>
        </member>
        <member name="F:NLog.Targets.FilePathKind.Relative">
            <summary>
            Relative path
            </summary>
        </member>
        <member name="F:NLog.Targets.FilePathKind.Absolute">
            <summary>
            Absolute path
            </summary>
            <remarks>Best for performance</remarks>
        </member>
        <member name="T:NLog.Targets.FileTarget">
            <summary>
            Writes log messages to one or more files.
            </summary>
            <remarks>
            <a href="https://github.com/nlog/nlog/wiki/File-target">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/nlog/nlog/wiki/File-target">Documentation on NLog Wiki</seealso>
        </member>
        <member name="F:NLog.Targets.FileTarget.InitializedFilesCleanupPeriod">
            <summary>
            Default clean up period of the initialized files. When a file exceeds the clean up period is removed from the list.
            </summary>
            <remarks>Clean up period is defined in days.</remarks>
        </member>
        <member name="F:NLog.Targets.FileTarget.ArchiveAboveSizeDisabled">
            <summary>
            This value disables file archiving based on the size.
            </summary>
        </member>
        <member name="F:NLog.Targets.FileTarget._initializedFiles">
            <summary>
            Holds the initialized files each given time by the <see cref="T:NLog.Targets.FileTarget"/> instance. Against each file, the last write time is stored.
            </summary>
            <remarks>Last write time is store in local time (no UTC).</remarks>
        </member>
        <member name="F:NLog.Targets.FileTarget._fileAppenderCache">
            <summary>
            List of the associated file appenders with the <see cref="T:NLog.Targets.FileTarget"/> instance.
            </summary>
        </member>
        <member name="F:NLog.Targets.FileTarget._initializedFilesCounter">
            <summary>
            The number of initialized files at any one time.
            </summary>
        </member>
        <member name="F:NLog.Targets.FileTarget._maxArchiveFiles">
            <summary>
            The maximum number of archive files that should be kept.
            </summary>
        </member>
        <member name="F:NLog.Targets.FileTarget._maxArchiveDays">
            <summary>
            The maximum days of archive files that should be kept.
            </summary>
        </member>
        <member name="F:NLog.Targets.FileTarget._fullFileName">
            <summary>
            The filename as target
            </summary>
        </member>
        <member name="F:NLog.Targets.FileTarget._fullArchiveFileName">
            <summary>
            The archive file name as target
            </summary>
        </member>
        <member name="F:NLog.Targets.FileTarget._previousLogEventTimestamp">
            <summary>
            The date of the previous log event.
            </summary>
        </member>
        <member name="F:NLog.Targets.FileTarget._previousLogFileName">
            <summary>
            The file name of the previous log event.
            </summary>
        </member>
        <member name="M:NLog.Targets.FileTarget.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.FileTarget" /> class.
            </summary>
            <remarks>
            The default value of the layout is: <code>${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}</code>
            </remarks>
        </member>
        <member name="M:NLog.Targets.FileTarget.#ctor(System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.FileTarget" /> class.
            </summary>
            <remarks>
            The default value of the layout is: <code>${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}</code>
            </remarks>
            <param name="name">Name of the target.</param>
        </member>
        <member name="P:NLog.Targets.FileTarget.FileName">
            <summary>
            Gets or sets the name of the file to write to.
            </summary>
            <remarks>
            This FileName string is a layout which may include instances of layout renderers.
            This lets you use a single target to write to multiple files.
            </remarks>
            <example>
            The following value makes NLog write logging events to files based on the log level in the directory where
            the application runs.
            <code>${basedir}/${level}.log</code>
            All <c>Debug</c> messages will go to <c>Debug.log</c>, all <c>Info</c> messages will go to <c>Info.log</c> and so on.
            You can combine as many of the layout renderers as you want to produce an arbitrary log file name.
            </example>
            <docgen category='General Options' order='2' />
        </member>
        <member name="P:NLog.Targets.FileTarget.CleanupFileName">
            <summary>
            Cleanup invalid values in a filename, e.g. slashes in a filename. If set to <c>true</c>, this can impact the performance of massive writes.
            If set to <c>false</c>, nothing gets written when the filename is wrong.
            </summary>
            <docgen category='Output Options' order='100' />
        </member>
        <member name="P:NLog.Targets.FileTarget.FileNameKind">
            <summary>
            Is the  <see cref="P:NLog.Targets.FileTarget.FileName"/> an absolute or relative path?
            </summary>
            <docgen category='Output Options' order='100' />
        </member>
        <member name="P:NLog.Targets.FileTarget.CreateDirs">
            <summary>
            Gets or sets a value indicating whether to create directories if they do not exist.
            </summary>
            <remarks>
            Setting this to false may improve performance a bit, but you'll receive an error
            when attempting to write to a directory that's not present.
            </remarks>
            <docgen category='Output Options' order='50' />
        </member>
        <member name="P:NLog.Targets.FileTarget.DeleteOldFileOnStartup">
            <summary>
            Gets or sets a value indicating whether to delete old log file on startup.
            </summary>
            <remarks>
            This option works only when the "FileName" parameter denotes a single file.
            </remarks>
            <docgen category='Output Options' order='50' />
        </member>
        <member name="P:NLog.Targets.FileTarget.ReplaceFileContentsOnEachWrite">
            <summary>
            Gets or sets a value indicating whether to replace file contents on each write instead of appending log message at the end.
            </summary>
            <docgen category='Output Options' order='100' />
        </member>
        <member name="P:NLog.Targets.FileTarget.KeepFileOpen">
            <summary>
            Gets or sets a value indicating whether to keep log file open instead of opening and closing it on each logging event.
            </summary>
            <remarks>
            KeepFileOpen = true gives the best performance, and ensure the file-lock is not lost to other applications.<br/>
            KeepFileOpen = false gives the best compability, but slow performance and lead to file-locking issues with other applications.
            </remarks>
            <docgen category='Performance Tuning Options' order='10' />
        </member>
        <member name="P:NLog.Targets.FileTarget.EnableFileDelete">
            <summary>
            Gets or sets a value indicating whether to enable log file(s) to be deleted.
            </summary>
            <docgen category='Output Options' order='50' />
        </member>
        <member name="P:NLog.Targets.FileTarget.FileAttributes">
            <summary>
            Gets or sets the file attributes (Windows only).
            </summary>
            <docgen category='Output Options' order='100' />
        </member>
        <member name="P:NLog.Targets.FileTarget.LineEnding">
            <summary>
            Gets or sets the line ending mode.
            </summary>
            <docgen category='Output Options' order='100' />
        </member>
        <member name="P:NLog.Targets.FileTarget.AutoFlush">
            <summary>
            Gets or sets a value indicating whether to automatically flush the file buffers after each log message.
            </summary>
            <docgen category='Performance Tuning Options' order='50' />
        </member>
        <member name="P:NLog.Targets.FileTarget.OpenFileCacheSize">
            <summary>
            Gets or sets the number of files to be kept open. Setting this to a higher value may improve performance
            in a situation where a single File target is writing to many files
            (such as splitting by level or by logger).
            </summary>
            <remarks>
            The files are managed on a LRU (least recently used) basis, which flushes
            the files that have not been used for the longest period of time should the
            cache become full. As a rule of thumb, you shouldn't set this parameter to
            a very high value. A number like 10-15 shouldn't be exceeded, because you'd
            be keeping a large number of files open which consumes system resources.
            </remarks>
            <docgen category='Performance Tuning Options' order='10' />
        </member>
        <member name="P:NLog.Targets.FileTarget.OpenFileCacheTimeout">
            <summary>
            Gets or sets the maximum number of seconds that files are kept open. Zero or negative means disabled.
            </summary>
            <docgen category='Performance Tuning Options' order='50' />
        </member>
        <member name="P:NLog.Targets.FileTarget.OpenFileFlushTimeout">
            <summary>
            Gets or sets the maximum number of seconds before open files are flushed. Zero or negative means disabled.
            </summary>
            <docgen category='Performance Tuning Options' order='50' />
        </member>
        <member name="P:NLog.Targets.FileTarget.BufferSize">
            <summary>
            Gets or sets the log file buffer size in bytes.
            </summary>
            <docgen category='Performance Tuning Options' order='50' />
        </member>
        <member name="P:NLog.Targets.FileTarget.Encoding">
            <summary>
            Gets or sets the file encoding.
            </summary>
            <docgen category='Output Options' order='10' />
        </member>
        <member name="P:NLog.Targets.FileTarget.DiscardAll">
            <summary>
            Gets or sets whether or not this target should just discard all data that its asked to write.
            Mostly used for when testing NLog Stack except final write
            </summary>
            <docgen category='Performance Tuning Options' order='100' />
        </member>
        <member name="P:NLog.Targets.FileTarget.ConcurrentWrites">
            <summary>
            Gets or sets a value indicating whether concurrent writes to the log file by multiple processes on the same host.
            </summary>
            <remarks>
            This makes multi-process logging possible. NLog uses a special technique
            that lets it keep the files open for writing.
            </remarks>
            <docgen category='Performance Tuning Options' order='10' />
        </member>
        <member name="P:NLog.Targets.FileTarget.NetworkWrites">
            <summary>
            Obsolete and replaced by <see cref="P:NLog.Targets.FileTarget.KeepFileOpen"/> = <c>false</c> with NLog v5.3.
            Gets or sets a value indicating whether concurrent writes to the log file by multiple processes on different network hosts.
            </summary>
            <remarks>
            This effectively prevents files from being kept open.
            </remarks>
            <docgen category='Performance Tuning Options' order='50' />
        </member>
        <member name="P:NLog.Targets.FileTarget.WriteBom">
             <summary>
             Gets or sets a value indicating whether to write BOM (byte order mark) in created files.
            
             Defaults to true for UTF-16 and UTF-32
             </summary>
             <docgen category='Output Options' order='50' />
        </member>
        <member name="P:NLog.Targets.FileTarget.ConcurrentWriteAttempts">
            <summary>
            Gets or sets the number of times the write is appended on the file before NLog
            discards the log message.
            </summary>
            <docgen category='Performance Tuning Options' order='100' />
        </member>
        <member name="P:NLog.Targets.FileTarget.ConcurrentWriteAttemptDelay">
            <summary>
            Gets or sets the delay in milliseconds to wait before attempting to write to the file again.
            </summary>
            <remarks>
            The actual delay is a random value between 0 and the value specified
            in this parameter. On each failed attempt the delay base is doubled
            up to <see cref="P:NLog.Targets.FileTarget.ConcurrentWriteAttempts" /> times.
            </remarks>
            <example>
            Assuming that ConcurrentWriteAttemptDelay is 10 the time to wait will be:<p/>
            a random value between 0 and 10 milliseconds - 1st attempt<br/>
            a random value between 0 and 20 milliseconds - 2nd attempt<br/>
            a random value between 0 and 40 milliseconds - 3rd attempt<br/>
            a random value between 0 and 80 milliseconds - 4th attempt<br/>
            ...<p/>
            and so on.
            </example>
            <docgen category='Performance Tuning Options' order='100' />
        </member>
        <member name="P:NLog.Targets.FileTarget.ArchiveOldFileOnStartup">
            <summary>
            Gets or sets a value indicating whether to archive old log file on startup.
            </summary>
            <remarks>
            This option works only when the "FileName" parameter denotes a single file.
            After archiving the old file, the current log file will be empty.
            </remarks>
            <docgen category='Archival Options' order='50' />
        </member>
        <member name="P:NLog.Targets.FileTarget.WriteHeaderWhenInitialFileNotEmpty">
            <summary>
            Gets or sets whether to write the Header on initial creation of file appender, even if the file is not empty.
            Default value is <see langword="false"/>, which means only write header when initial file is empty (Ex. ensures valid CSV files)
            </summary>
            <remarks>
            Alternative use <see cref="P:NLog.Targets.FileTarget.ArchiveOldFileOnStartup"/> to ensure each application session gets individual log-file.
            </remarks>
        </member>
        <member name="P:NLog.Targets.FileTarget.ArchiveOldFileOnStartupAboveSize">
            <summary>
            Gets or sets a value of the file size threshold to archive old log file on startup.
            </summary>
            <remarks>
            This option won't work if <see cref="P:NLog.Targets.FileTarget.ArchiveOldFileOnStartup"/> is set to <c>false</c>
            Default value is 0 which means that the file is archived as soon as archival on
            startup is enabled.
            </remarks>
            <docgen category='Archival Options' order='50' />
        </member>
        <member name="P:NLog.Targets.FileTarget.ArchiveDateFormat">
            <summary>
            Gets or sets a value specifying the date format to use when archiving files.
            </summary>
            <remarks>
            This option works only when the "ArchiveNumbering" parameter is set either to Date or DateAndSequence.
            </remarks>
            <docgen category='Archival Options' order='50' />
        </member>
        <member name="P:NLog.Targets.FileTarget.ArchiveAboveSize">
            <summary>
            Gets or sets the size in bytes above which log files will be automatically archived.
            </summary>
            <remarks>
            Notice when combined with <see cref="F:NLog.Targets.ArchiveNumberingMode.Date"/> then it will attempt to append to any existing
            archive file if grown above size multiple times. New archive file will be created when using <see cref="F:NLog.Targets.ArchiveNumberingMode.DateAndSequence"/>
            </remarks>
            <docgen category='Archival Options' order='50' />
        </member>
        <member name="P:NLog.Targets.FileTarget.ArchiveEvery">
            <summary>
            Gets or sets a value indicating whether to automatically archive log files every time the specified time passes.
            </summary>
            <remarks>
            Files are moved to the archive as part of the write operation if the current period of time changes. For example
            if the current <c>hour</c> changes from 10 to 11, the first write that will occur
            on or after 11:00 will trigger the archiving.
            </remarks>
            <docgen category='Archival Options' order='50' />
        </member>
        <member name="P:NLog.Targets.FileTarget.ArchiveFileKind">
            <summary>
            Is the  <see cref="P:NLog.Targets.FileTarget.ArchiveFileName"/> an absolute or relative path?
            </summary>
            <docgen category='Archival Options' order='50' />
        </member>
        <member name="P:NLog.Targets.FileTarget.ArchiveFileName">
            <summary>
            Gets or sets the name of the file to be used for an archive.
            </summary>
            <remarks>
            It may contain a special placeholder {#####}
            that will be replaced with a sequence of numbers depending on
            the archiving strategy. The number of hash characters used determines
            the number of numerical digits to be used for numbering files.
            </remarks>
            <docgen category='Archival Options' order='50' />
        </member>
        <member name="P:NLog.Targets.FileTarget.MaxArchiveFiles">
            <summary>
            Gets or sets the maximum number of archive files that should be kept.
            </summary>
            <docgen category='Archival Options' order='50' />
        </member>
        <member name="P:NLog.Targets.FileTarget.MaxArchiveDays">
            <summary>
            Gets or sets the maximum days of archive files that should be kept.
            </summary>
            <docgen category='Archival Options' order='50' />
        </member>
        <member name="P:NLog.Targets.FileTarget.ArchiveNumbering">
            <summary>
            Gets or sets the way file archives are numbered.
            </summary>
            <docgen category='Archival Options' order='50' />
        </member>
        <member name="P:NLog.Targets.FileTarget.FileCompressor">
            <summary>
            Used to compress log files during archiving.
            This may be used to provide your own implementation of a zip file compressor,
            on platforms other than .Net4.5.
            Defaults to ZipArchiveFileCompressor on .Net4.5 and to null otherwise.
            </summary>
            <docgen category='Archival Options' order='50' />
        </member>
        <member name="P:NLog.Targets.FileTarget.EnableArchiveFileCompression">
            <summary>
            Gets or sets a value indicating whether to compress archive files into the zip archive format.
            </summary>
            <docgen category='Archival Options' order='50' />
        </member>
        <member name="P:NLog.Targets.FileTarget.ForceManaged">
            <summary>
            Gets or set a value indicating whether a managed file stream is forced, instead of using the native implementation.
            </summary>
            <docgen category='Output Options' order='100' />
        </member>
        <member name="P:NLog.Targets.FileTarget.ForceMutexConcurrentWrites">
            <summary>
            Gets or sets a value indicating whether file creation calls should be synchronized by a system global mutex.
            </summary>
            <docgen category='Output Options' order='100' />
        </member>
        <member name="P:NLog.Targets.FileTarget.WriteFooterOnArchivingOnly">
            <summary>
            Gets or sets a value indicating whether the footer should be written only when the file is archived.
            </summary>
            <docgen category='Archival Options' order='50' />
        </member>
        <member name="P:NLog.Targets.FileTarget.NewLineChars">
            <summary>
            Gets the characters that are appended after each line.
            </summary>
        </member>
        <member name="M:NLog.Targets.FileTarget.RefreshArchiveFilePatternToWatch(System.String,NLog.LogEventInfo)">
            <summary>
            Refresh the ArchiveFilePatternToWatch option of the <see cref="T:NLog.Internal.FileAppenders.FileAppenderCache" />.
            The log file must be watched for archiving when multiple processes are writing to the same
            open file.
            </summary>
        </member>
        <member name="M:NLog.Targets.FileTarget.CleanupInitializedFiles">
            <summary>
            Removes records of initialized files that have not been
            accessed in the last two days.
            </summary>
            <remarks>
            Files are marked 'initialized' for the purpose of writing footers when the logging finishes.
            </remarks>
        </member>
        <member name="M:NLog.Targets.FileTarget.CleanupInitializedFiles(System.DateTime)">
            <summary>
            Removes records of initialized files that have not been
            accessed after the specified date.
            </summary>
            <param name="cleanupThreshold">The cleanup threshold.</param>
            <remarks>
            Files are marked 'initialized' for the purpose of writing footers when the logging finishes.
            </remarks>
        </member>
        <member name="M:NLog.Targets.FileTarget.FlushAsync(NLog.Common.AsyncContinuation)">
            <summary>
            Flushes all pending file operations.
            </summary>
            <param name="asyncContinuation">The asynchronous continuation.</param>
            <remarks>
            The timeout parameter is ignored, because file APIs don't provide
            the needed functionality.
            </remarks>
        </member>
        <member name="M:NLog.Targets.FileTarget.GetFileAppenderFactory">
             <summary>
             Returns the suitable appender factory ( <see cref="T:NLog.Internal.FileAppenders.IFileAppenderFactory"/>) to be used to generate the file
             appenders associated with the <see cref="T:NLog.Targets.FileTarget"/> instance.
            
             The type of the file appender factory returned depends on the values of various <see cref="T:NLog.Targets.FileTarget"/> properties.
             </summary>
             <returns><see cref="T:NLog.Internal.FileAppenders.IFileAppenderFactory"/> suitable for this instance.</returns>
        </member>
        <member name="M:NLog.Targets.FileTarget.InitializeTarget">
            <summary>
            Initializes file logging by creating data structures that
            enable efficient multi-file logging.
            </summary>
        </member>
        <member name="M:NLog.Targets.FileTarget.CloseTarget">
            <summary>
            Closes the file(s) opened for writing.
            </summary>
        </member>
        <member name="M:NLog.Targets.FileTarget.Write(NLog.LogEventInfo)">
            <summary>
            Writes the specified logging event to a file specified in the FileName
            parameter.
            </summary>
            <param name="logEvent">The logging event.</param>
        </member>
        <member name="M:NLog.Targets.FileTarget.GetFullFileName(NLog.LogEventInfo)">
            <summary>
            Get full filename (=absolute) and cleaned if needed.
            </summary>
            <param name="logEvent"></param>
            <returns></returns>
        </member>
        <member name="M:NLog.Targets.FileTarget.Write(System.Collections.Generic.IList{NLog.Common.AsyncLogEventInfo})">
            <summary>
            Writes the specified array of logging events to a file specified in the FileName
            parameter.
            </summary>
            <param name="logEvents">An array of <see cref="T:NLog.Common.AsyncLogEventInfo"/> objects.</param>
            <remarks>
            This function makes use of the fact that the events are batched by sorting
            the requests by filename. This optimizes the number of open/close calls
            and can help improve performance.
            </remarks>
        </member>
        <member name="M:NLog.Targets.FileTarget.GetFormattedMessage(NLog.LogEventInfo)">
            <summary>
            Obsolete and replaced by <see cref="M:NLog.Targets.FileTarget.RenderFormattedMessage(NLog.LogEventInfo,System.Text.StringBuilder)"/> with NLog v5.
            Formats the log event for write.
            </summary>
            <param name="logEvent">The log event to be formatted.</param>
            <returns>A string representation of the log event.</returns>
        </member>
        <member name="M:NLog.Targets.FileTarget.GetBytesToWrite(NLog.LogEventInfo)">
            <summary>
            Obsolete and replaced by <see cref="M:NLog.Targets.FileTarget.RenderFormattedMessage(NLog.LogEventInfo,System.Text.StringBuilder)"/> with NLog v5.
            Gets the bytes to be written to the file.
            </summary>
            <param name="logEvent">Log event.</param>
            <returns>Array of bytes that are ready to be written.</returns>
        </member>
        <member name="M:NLog.Targets.FileTarget.TransformBytes(System.Byte[])">
            <summary>
            Obsolete and replaced by <see cref="M:NLog.Targets.FileTarget.TransformStream(NLog.LogEventInfo,System.IO.MemoryStream)"/> with NLog v5.
            Modifies the specified byte array before it gets sent to a file.
            </summary>
            <param name="value">The byte array.</param>
            <returns>The modified byte array. The function can do the modification in-place.</returns>
        </member>
        <member name="M:NLog.Targets.FileTarget.RenderFormattedMessageToStream(NLog.LogEventInfo,System.Text.StringBuilder,System.Char[],System.IO.MemoryStream)">
            <summary>
            Gets the bytes to be written to the file.
            </summary>
            <param name="logEvent">The log event to be formatted.</param>
            <param name="formatBuilder"><see cref="T:System.Text.StringBuilder"/> to help format log event.</param>
            <param name="transformBuffer">Optional temporary char-array to help format log event.</param>
            <param name="streamTarget">Destination <see cref="T:System.IO.MemoryStream"/> for the encoded result.</param>
        </member>
        <member name="M:NLog.Targets.FileTarget.RenderFormattedMessage(NLog.LogEventInfo,System.Text.StringBuilder)">
            <summary>
            Formats the log event for write.
            </summary>
            <param name="logEvent">The log event to be formatted.</param>
            <param name="target"><see cref="T:System.Text.StringBuilder"/> for the result.</param>
        </member>
        <member name="M:NLog.Targets.FileTarget.TransformStream(NLog.LogEventInfo,System.IO.MemoryStream)">
            <summary>
            Modifies the specified byte array before it gets sent to a file.
            </summary>
            <param name="logEvent">The LogEvent being written</param>
            <param name="stream">The byte array.</param>
        </member>
        <member name="M:NLog.Targets.FileTarget.ArchiveFile(System.String,System.String)">
            <summary>
            Archives fileName to archiveFileName.
            </summary>
            <param name="fileName">File name to be archived.</param>
            <param name="archiveFileName">Name of the archive file.</param>
        </member>
        <member name="M:NLog.Targets.FileTarget.GetArchiveDateFormatString(System.String)">
             <summary>
             Gets the correct formatting <see langword="String"/> to be used based on the value of <see
             cref="P:NLog.Targets.FileTarget.ArchiveEvery"/> for converting <see langword="DateTime"/> values which will be inserting into file
             names during archiving.
            
             This value will be computed only when a empty value or <see langword="null"/> is passed into <paramref name="defaultFormat"/>
             </summary>
             <param name="defaultFormat">Date format to used irrespectively of <see cref="P:NLog.Targets.FileTarget.ArchiveEvery"/> value.</param>
             <returns>Formatting <see langword="String"/> for dates.</returns>
        </member>
        <member name="M:NLog.Targets.FileTarget.CalculateNextWeekday(System.DateTime,System.DayOfWeek)">
            <summary>
            Calculate the DateTime of the requested day of the week.
            </summary>
            <param name="previousLogEventTimestamp">The DateTime of the previous log event.</param>
            <param name="dayOfWeek">The next occurring day of the week to return a DateTime for.</param>
            <returns>The DateTime of the next occurring dayOfWeek.</returns>
            <remarks>For example: if previousLogEventTimestamp is Thursday 2017-03-02 and dayOfWeek is Sunday, this will return
             Sunday 2017-03-05. If dayOfWeek is Thursday, this will return *next* Thursday 2017-03-09.</remarks>
        </member>
        <member name="M:NLog.Targets.FileTarget.DoAutoArchive(System.String,NLog.LogEventInfo,System.DateTime,System.Boolean)">
            <summary>
            Invokes the archiving process after determining when and which type of archiving is required.
            </summary>
            <param name="fileName">File name to be checked and archived.</param>
            <param name="eventInfo">Log event that the <see cref="T:NLog.Targets.FileTarget"/> instance is currently processing.</param>
            <param name="previousLogEventTimestamp">The DateTime of the previous log event for this file.</param>
            <param name="initializedNewFile">File has just been opened.</param>
        </member>
        <member name="M:NLog.Targets.FileTarget.GetArchiveFileNamePattern(System.String,NLog.LogEventInfo)">
            <summary>
            Gets the pattern that archive files will match
            </summary>
            <param name="fileName">Filename of the log file</param>
            <param name="eventInfo">Log event that the <see cref="T:NLog.Targets.FileTarget"/> instance is currently processing.</param>
            <returns>A string with a pattern that will match the archive filenames</returns>
        </member>
        <member name="M:NLog.Targets.FileTarget.TryArchiveFile(System.String,NLog.LogEventInfo,System.Int32,System.DateTime,System.Boolean)">
            <summary>
            Archives the file if it should be archived.
            </summary>
            <param name="fileName">The file name to check for.</param>
            <param name="ev">Log event that the <see cref="T:NLog.Targets.FileTarget"/> instance is currently processing.</param>
            <param name="upcomingWriteSize">The size in bytes of the next chunk of data to be written in the file.</param>
            <param name="previousLogEventTimestamp">The DateTime of the previous log event for this file.</param>
            <param name="initializedNewFile">File has just been opened.</param>
            <returns>True when archive operation of the file was completed (by this target or a concurrent target)</returns>
        </member>
        <member name="M:NLog.Targets.FileTarget.TryCloseFileAppenderBeforeArchive(System.String,System.String)">
            <summary>
            Closes any active file-appenders that matches the input filenames.
            File-appender is requested to invalidate/close its filehandle, but keeping its archive-mutex alive
            </summary>
        </member>
        <member name="M:NLog.Targets.FileTarget.GetArchiveFileName(System.String,NLog.LogEventInfo,System.Int32,System.DateTime,System.Boolean)">
            <summary>
            Indicates if the automatic archiving process should be executed.
            </summary>
            <param name="fileName">File name to be written.</param>
            <param name="ev">Log event that the <see cref="T:NLog.Targets.FileTarget"/> instance is currently processing.</param>
            <param name="upcomingWriteSize">The size in bytes of the next chunk of data to be written in the file.</param>
            <param name="previousLogEventTimestamp">The DateTime of the previous log event for this file.</param>
            <param name="initializedNewFile">File has just been opened.</param>
            <returns>Filename to archive. If <c>null</c>, then nothing to archive.</returns>
        </member>
        <member name="M:NLog.Targets.FileTarget.GetPotentialFileForArchiving(System.String)">
            <summary>
            Returns the correct filename to archive
            </summary>
        </member>
        <member name="M:NLog.Targets.FileTarget.GetArchiveFileNameBasedOnFileSize(System.String,System.Int32,System.Boolean)">
            <summary>
            Gets the file name for archiving, or null if archiving should not occur based on file size.
            </summary>
            <param name="fileName">File name to be written.</param>
            <param name="upcomingWriteSize">The size in bytes of the next chunk of data to be written in the file.</param>
            <param name="initializedNewFile">File has just been opened.</param>
            <returns>Filename to archive. If <c>null</c>, then nothing to archive.</returns>
        </member>
        <member name="M:NLog.Targets.FileTarget.TryFallbackToPreviousLogFileName(System.String,System.Boolean)">
            <summary>
            Check if archive operation should check previous filename, because FileAppenderCache tells us current filename no longer exists
            </summary>
        </member>
        <member name="M:NLog.Targets.FileTarget.GetArchiveFileNameBasedOnTime(System.String,NLog.LogEventInfo,System.DateTime,System.Boolean)">
            <summary>
            Returns the file name for archiving, or null if archiving should not occur based on date/time.
            </summary>
            <param name="fileName">File name to be written.</param>
            <param name="logEvent">Log event that the <see cref="T:NLog.Targets.FileTarget"/> instance is currently processing.</param>
            <param name="previousLogEventTimestamp">The DateTime of the previous log event for this file.</param>
            <param name="initializedNewFile">File has just been opened.</param>
            <returns>Filename to archive. If <c>null</c>, then nothing to archive.</returns>
        </member>
        <member name="M:NLog.Targets.FileTarget.TruncateArchiveTime(System.DateTime,NLog.Targets.FileArchivePeriod)">
            <summary>
            Truncates the input-time, so comparison of low resolution times (like dates) are not affected by ticks
            </summary>
            <param name="input">High resolution Time</param>
            <param name="resolution">Time Resolution Level</param>
            <returns>Truncated Low Resolution Time</returns>
        </member>
        <member name="M:NLog.Targets.FileTarget.WriteToFile(System.String,System.ArraySegment{System.Byte},System.Boolean)">
            <summary>
            Evaluates which parts of a file should be written (header, content, footer) based on various properties of
            <see cref="T:NLog.Targets.FileTarget"/> instance and writes them.
            </summary>
            <param name="fileName">File name to be written.</param>
            <param name="bytes">Raw sequence of <see langword="byte"/> to be written into the content part of the file.</param>
            <param name="initializedNewFile">File has just been opened.</param>
        </member>
        <member name="M:NLog.Targets.FileTarget.InitializeFile(System.String,NLog.LogEventInfo)">
            <summary>
            Initialize a file to be used by the <see cref="T:NLog.Targets.FileTarget"/> instance. Based on the number of initialized
            files and the values of various instance properties clean up and/or archiving processes can be invoked.
            </summary>
            <param name="fileName">File name to be written.</param>
            <param name="logEvent">Log event that the <see cref="T:NLog.Targets.FileTarget"/> instance is currently processing.</param>
            <returns>The DateTime of the previous log event for this file (DateTime.MinValue if just initialized).</returns>
        </member>
        <member name="M:NLog.Targets.FileTarget.FinalizeFile(System.String,System.Boolean)">
            <summary>
            Writes the file footer and finalizes the file in <see cref="T:NLog.Targets.FileTarget"/> instance internal structures.
            </summary>
            <param name="fileName">File name to close.</param>
            <param name="isArchiving">Indicates if the file is being finalized for archiving.</param>
        </member>
        <member name="M:NLog.Targets.FileTarget.WriteFooter(System.String)">
            <summary>
            Writes the footer information to a file.
            </summary>
            <param name="fileName">The file path to write to.</param>
        </member>
        <member name="M:NLog.Targets.FileTarget.ShouldArchiveOldFileOnStartup(System.String)">
            <summary>
            Decision logic whether to archive logfile on startup.
            <see cref="P:NLog.Targets.FileTarget.ArchiveOldFileOnStartup"/> and <see cref="P:NLog.Targets.FileTarget.ArchiveOldFileOnStartupAboveSize"/> properties.
            </summary>
            <param name="fileName">File name to be written.</param>
            <returns>Decision whether to archive or not.</returns>
        </member>
        <member name="M:NLog.Targets.FileTarget.PrepareForNewFile(System.String,NLog.LogEventInfo)">
            <summary>
            Invokes the archiving and clean up of older archive file based on the values of
            <see cref="P:NLog.Targets.FileTarget.ArchiveOldFileOnStartup"/> and
            <see cref="P:NLog.Targets.FileTarget.DeleteOldFileOnStartup"/> properties respectively.
            </summary>
            <param name="fileName">File name to be written.</param>
            <param name="logEvent">Log event that the <see cref="T:NLog.Targets.FileTarget"/> instance is currently processing.</param>
        </member>
        <member name="M:NLog.Targets.FileTarget.ReplaceFileContent(System.String,System.ArraySegment{System.Byte},System.Boolean)">
            <summary>
            Creates the file specified in <paramref name="fileName"/> and writes the file content in each entirety i.e.
            Header, Content and Footer.
            </summary>
            <param name="fileName">The name of the file to be written.</param>
            <param name="bytes">Sequence of <see langword="byte"/> to be written in the content section of the file.</param>
            <param name="firstAttempt">First attempt to write?</param>
            <remarks>This method is used when the content of the log file is re-written on every write.</remarks>
        </member>
        <member name="M:NLog.Targets.FileTarget.WriteHeaderAndBom(NLog.Internal.FileAppenders.BaseFileAppender)">
            <summary>
            Writes the header information and byte order mark to a file.
            </summary>
            <param name="appender">File appender associated with the file.</param>
        </member>
        <member name="M:NLog.Targets.FileTarget.GetLayoutBytes(NLog.Layouts.Layout)">
            <summary>
            The sequence of <see langword="byte"/> to be written in a file after applying any formatting and any
            transformations required from the <see cref="T:NLog.Layouts.Layout"/>.
            </summary>
            <param name="layout">The layout used to render output message.</param>
            <returns>Sequence of <see langword="byte"/> to be written.</returns>
            <remarks>Usually it is used to render the header and hooter of the files.</remarks>
        </member>
        <member name="T:NLog.Targets.IArchiveFileCompressor">
            <summary>
            <see cref="T:NLog.Targets.FileTarget"/> may be configured to compress archived files in a custom way
            by setting <see cref="P:NLog.Targets.FileTarget.FileCompressor"/> before logging your first event.
            </summary>
        </member>
        <member name="M:NLog.Targets.IArchiveFileCompressor.CompressFile(System.String,System.String,System.String)">
            <summary>
            Create archiveFileName by compressing fileName.
            </summary>
            <param name="fileName">Absolute path to the log file to compress.</param>
            <param name="archiveFileName">Absolute path to the compressed archive file to create.</param>
            <param name="entryName">The name of the file inside the archive.</param>
        </member>
        <member name="T:NLog.Targets.IColoredConsolePrinter">
            <summary>
            Controls the text and color formatting for <see cref="T:NLog.Targets.ColoredConsoleTarget"/>
            </summary>
        </member>
        <member name="M:NLog.Targets.IColoredConsolePrinter.AcquireTextWriter(System.IO.TextWriter,System.Text.StringBuilder)">
            <summary>
            Creates a TextWriter for the console to start building a colored text message
            </summary>
            <param name="consoleStream">Active console stream</param>
            <param name="reusableBuilder">Optional StringBuilder to optimize performance</param>
            <returns>TextWriter for the console</returns>
        </member>
        <member name="M:NLog.Targets.IColoredConsolePrinter.ReleaseTextWriter(System.IO.TextWriter,System.IO.TextWriter,System.Nullable{System.ConsoleColor},System.Nullable{System.ConsoleColor},System.Boolean)">
            <summary>
            Releases the TextWriter for the console after having built a colored text message (Restores console colors)
            </summary>
            <param name="consoleWriter">Colored TextWriter</param>
            <param name="consoleStream">Active console stream</param>
            <param name="oldForegroundColor">Original foreground color for console (If changed)</param>
            <param name="oldBackgroundColor">Original background color for console (If changed)</param>
            <param name="flush">Flush TextWriter</param>
        </member>
        <member name="M:NLog.Targets.IColoredConsolePrinter.ChangeForegroundColor(System.IO.TextWriter,System.Nullable{System.ConsoleColor},System.Nullable{System.ConsoleColor})">
            <summary>
            Changes foreground color for the Colored TextWriter
            </summary>
            <param name="consoleWriter">Colored TextWriter</param>
            <param name="foregroundColor">New foreground color for the console</param>
            <param name="oldForegroundColor">Old previous backgroundColor color for the console</param>
            <returns>Old foreground color for the console</returns>
        </member>
        <member name="M:NLog.Targets.IColoredConsolePrinter.ChangeBackgroundColor(System.IO.TextWriter,System.Nullable{System.ConsoleColor},System.Nullable{System.ConsoleColor})">
            <summary>
            Changes backgroundColor color for the Colored TextWriter
            </summary>
            <param name="consoleWriter">Colored TextWriter</param>
            <param name="backgroundColor">New backgroundColor color for the console</param>
            <param name="oldBackgroundColor">Old previous backgroundColor color for the console</param>
            <returns>Old backgroundColor color for the console</returns>
        </member>
        <member name="M:NLog.Targets.IColoredConsolePrinter.ResetDefaultColors(System.IO.TextWriter,System.Nullable{System.ConsoleColor},System.Nullable{System.ConsoleColor})">
            <summary>
            Restores console colors back to their original state
            </summary>
            <param name="consoleWriter">Colored TextWriter</param>
            <param name="foregroundColor">Original foregroundColor color for the console</param>
            <param name="backgroundColor">Original backgroundColor color for the console</param>
        </member>
        <member name="M:NLog.Targets.IColoredConsolePrinter.WriteSubString(System.IO.TextWriter,System.String,System.Int32,System.Int32)">
            <summary>
            Writes multiple characters to console in one operation (faster)
            </summary>
            <param name="consoleWriter">Colored TextWriter</param>
            <param name="text">Output Text</param>
            <param name="index">Start Index</param>
            <param name="endIndex">End Index</param>
        </member>
        <member name="M:NLog.Targets.IColoredConsolePrinter.WriteChar(System.IO.TextWriter,System.Char)">
            <summary>
            Writes single character to console
            </summary>
            <param name="consoleWriter">Colored TextWriter</param>
            <param name="text">Output Text</param>
        </member>
        <member name="M:NLog.Targets.IColoredConsolePrinter.WriteLine(System.IO.TextWriter,System.String)">
            <summary>
            Writes whole string and completes with newline
            </summary>
            <param name="consoleWriter">Colored TextWriter</param>
            <param name="text">Output Text</param>
        </member>
        <member name="P:NLog.Targets.IColoredConsolePrinter.DefaultConsoleRowHighlightingRules">
            <summary>
            Default row highlight rules for the console printer
            </summary>
        </member>
        <member name="M:NLog.Targets.IFileArchiveMode.AttemptCleanupOnInitializeFile(System.String,System.Int32,System.Int32)">
            <summary>
            Check if cleanup should be performed on initialize new file
            </summary>
            <param name="archiveFilePath">Base archive file pattern</param>
            <param name="maxArchiveFiles">Maximum number of archive files that should be kept</param>
            <param name="maxArchiveDays">Maximum days of archive files that should be kept</param>
            <returns>True, when archive cleanup is needed</returns>
        </member>
        <member name="M:NLog.Targets.IFileArchiveMode.GenerateFileNameMask(System.String)">
            <summary>
            Create a wildcard file-mask that allows one to find all files belonging to the same archive.
            </summary>
            <param name="archiveFilePath">Base archive file pattern</param>
            <returns>Wildcard file-mask</returns>
        </member>
        <member name="M:NLog.Targets.IFileArchiveMode.GetExistingArchiveFiles(System.String)">
            <summary>
            Search directory for all existing files that are part of the same archive.
            </summary>
            <param name="archiveFilePath">Base archive file pattern</param>
            <returns></returns>
        </member>
        <member name="M:NLog.Targets.IFileArchiveMode.GenerateArchiveFileName(System.String,System.DateTime,System.Collections.Generic.List{NLog.Targets.DateAndSequenceArchive})">
            <summary>
            Generate the next archive filename for the archive.
            </summary>
            <param name="archiveFilePath">Base archive file pattern</param>
            <param name="archiveDate">File date of archive</param>
            <param name="existingArchiveFiles">Existing files in the same archive</param>
            <returns></returns>
        </member>
        <member name="M:NLog.Targets.IFileArchiveMode.CheckArchiveCleanup(System.String,System.Collections.Generic.List{NLog.Targets.DateAndSequenceArchive},System.Int32,System.Int32)">
            <summary>
            Return all files that should be removed from the provided archive.
            </summary>
            <param name="archiveFilePath">Base archive file pattern</param>
            <param name="existingArchiveFiles">Existing files in the same archive</param>
            <param name="maxArchiveFiles">Maximum number of archive files that should be kept</param>
            <param name="maxArchiveDays">Maximum days of archive files that should be kept</param>
        </member>
        <member name="T:NLog.Targets.IFileCompressor">
            <summary>
            <see cref="T:NLog.Targets.FileTarget"/> may be configured to compress archived files in a custom way
            by setting <see cref="P:NLog.Targets.FileTarget.FileCompressor"/> before logging your first event.
            </summary>
        </member>
        <member name="M:NLog.Targets.IFileCompressor.CompressFile(System.String,System.String)">
            <summary>
            Create archiveFileName by compressing fileName.
            </summary>
            <param name="fileName">Absolute path to the log file to compress.</param>
            <param name="archiveFileName">Absolute path to the compressed archive file to create.</param>
        </member>
        <member name="T:NLog.Targets.JsonSerializeOptions">
            <summary>
            Options for JSON serialization
            </summary>
        </member>
        <member name="P:NLog.Targets.JsonSerializeOptions.QuoteKeys">
            <summary>
            Add quotes around object keys?
            </summary>
        </member>
        <member name="P:NLog.Targets.JsonSerializeOptions.FormatProvider">
            <summary>
            Format provider for value
            </summary>
        </member>
        <member name="P:NLog.Targets.JsonSerializeOptions.Format">
            <summary>
            Format string for value
            </summary>
        </member>
        <member name="P:NLog.Targets.JsonSerializeOptions.EscapeUnicode">
            <summary>
            Should non-ascii characters be encoded
            </summary>
        </member>
        <member name="P:NLog.Targets.JsonSerializeOptions.EscapeForwardSlash">
            <summary>
            Should forward slashes be escaped? If true, / will be converted to \/
            </summary>
        </member>
        <member name="P:NLog.Targets.JsonSerializeOptions.EnumAsInteger">
            <summary>
            Serialize enum as string value
            </summary>
        </member>
        <member name="P:NLog.Targets.JsonSerializeOptions.SanitizeDictionaryKeys">
             <summary>
             Should dictionary keys be sanitized. All characters must either be letters, numbers or underscore character (_).
            
             Any other characters will be converted to underscore character (_)
             </summary>
        </member>
        <member name="P:NLog.Targets.JsonSerializeOptions.MaxRecursionLimit">
            <summary>
            How far down the rabbit hole should the Json Serializer go with object-reflection before stopping
            </summary>
        </member>
        <member name="T:NLog.Targets.LineEndingMode">
            <summary>
            Line ending mode.
            </summary>
        </member>
        <member name="F:NLog.Targets.LineEndingMode.Default">
            <summary>
            Insert platform-dependent end-of-line sequence after each line.
            </summary>
        </member>
        <member name="F:NLog.Targets.LineEndingMode.CRLF">
            <summary>
            Insert CR LF sequence (ASCII 13, ASCII 10) after each line.
            </summary>
        </member>
        <member name="F:NLog.Targets.LineEndingMode.CR">
            <summary>
            Insert CR character (ASCII 13) after each line.
            </summary>
        </member>
        <member name="F:NLog.Targets.LineEndingMode.LF">
            <summary>
            Insert LF character (ASCII 10) after each line.
            </summary>
        </member>
        <member name="F:NLog.Targets.LineEndingMode.Null">
            <summary>
            Insert null terminator (ASCII 0) after each line.
            </summary>
        </member>
        <member name="F:NLog.Targets.LineEndingMode.None">
            <summary>
            Do not insert any line ending.
            </summary>
        </member>
        <member name="P:NLog.Targets.LineEndingMode.Name">
            <summary>
            Gets the name of the LineEndingMode instance.
            </summary>
        </member>
        <member name="P:NLog.Targets.LineEndingMode.NewLineCharacters">
            <summary>
            Gets the new line characters (value) of the LineEndingMode instance.
            </summary>
        </member>
        <member name="M:NLog.Targets.LineEndingMode.#ctor(System.String,System.String)">
            <summary>
            Initializes a new instance of <see cref="T:NLog.LogLevel"/>.
            </summary>
            <param name="name">The mode name.</param>
            <param name="newLineCharacters">The new line characters to be used.</param>
        </member>
        <member name="M:NLog.Targets.LineEndingMode.FromString(System.String)">
            <summary>
             Returns the <see cref="T:NLog.Targets.LineEndingMode"/> that corresponds to the supplied <paramref name="name"/>.
            </summary>
            <param name="name">
             The textual representation of the line ending mode, such as CRLF, LF, Default etc.
             Name is not case sensitive.
            </param>
            <returns>The <see cref="T:NLog.Targets.LineEndingMode"/> value, that corresponds to the <paramref name="name"/>.</returns>
            <exception cref="T:System.ArgumentOutOfRangeException">There is no line ending mode with the specified name.</exception>
        </member>
        <member name="M:NLog.Targets.LineEndingMode.op_Equality(NLog.Targets.LineEndingMode,NLog.Targets.LineEndingMode)">
            <summary>
            Compares two <see cref="T:NLog.Targets.LineEndingMode"/> objects and returns a
            value indicating whether the first one is equal to the second one.
            </summary>
            <param name="mode1">The first level.</param>
            <param name="mode2">The second level.</param>
            <returns>The value of <c>mode1.NewLineCharacters == mode2.NewLineCharacters</c>.</returns>
        </member>
        <member name="M:NLog.Targets.LineEndingMode.op_Inequality(NLog.Targets.LineEndingMode,NLog.Targets.LineEndingMode)">
            <summary>
            Compares two <see cref="T:NLog.Targets.LineEndingMode"/> objects and returns a
            value indicating whether the first one is not equal to the second one.
            </summary>
            <param name="mode1">The first mode</param>
            <param name="mode2">The second mode</param>
            <returns>The value of <c>mode1.NewLineCharacters != mode2.NewLineCharacters</c>.</returns>
        </member>
        <member name="M:NLog.Targets.LineEndingMode.ToString">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Targets.LineEndingMode.GetHashCode">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Targets.LineEndingMode.Equals(System.Object)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Targets.LineEndingMode.Equals(NLog.Targets.LineEndingMode)">
            <summary>Indicates whether the current object is equal to another object of the same type.</summary>
            <returns>true if the current object is equal to the <paramref name="other" /> parameter; otherwise, false.</returns>
            <param name="other">An object to compare with this object.</param>
        </member>
        <member name="T:NLog.Targets.LineEndingMode.LineEndingModeConverter">
            <summary>
            Provides a type converter to convert <see cref="T:NLog.Targets.LineEndingMode"/> objects to and from other representations.
            </summary>
        </member>
        <member name="M:NLog.Targets.LineEndingMode.LineEndingModeConverter.CanConvertFrom(System.ComponentModel.ITypeDescriptorContext,System.Type)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Targets.LineEndingMode.LineEndingModeConverter.ConvertFrom(System.ComponentModel.ITypeDescriptorContext,System.Globalization.CultureInfo,System.Object)">
            <inheritdoc/>
        </member>
        <member name="T:NLog.Targets.MailTarget">
            <summary>
            Sends log messages by email using SMTP protocol.
            </summary>
            <remarks>
            <a href="https://github.com/nlog/nlog/wiki/Mail-target">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/nlog/nlog/wiki/Mail-target">Documentation on NLog Wiki</seealso>
            <example>
            <p>
            To set up the target in the <a href="https://github.com/NLog/NLog/wiki/Configuration-file">configuration file</a>,
            use the following syntax:
            </p>
            <code lang="XML" source="examples/targets/Configuration File/Mail/Simple/NLog.config" />
            <p>
            To set up the log target programmatically use code like this:
            </p>
            <code lang="C#" source="examples/targets/Configuration API/Mail/Simple/Example.cs" />
            <p>
            Mail target works best when used with BufferingWrapper target
            which lets you send multiple log messages in single mail
            </p>
            <p>
            To set up the buffered mail target in the <a href="https://github.com/NLog/NLog/wiki/Configuration-file">configuration file</a>,
            use the following syntax:
            </p>
            <code lang="XML" source="examples/targets/Configuration File/Mail/Buffered/NLog.config" />
            <p>
            To set up the buffered mail target programmatically use code like this:
            </p>
            <code lang="C#" source="examples/targets/Configuration API/Mail/Buffered/Example.cs" />
            </example>
        </member>
        <member name="M:NLog.Targets.MailTarget.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.MailTarget" /> class.
            </summary>
            <remarks>
            The default value of the layout is: <code>${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}</code>
            </remarks>
        </member>
        <member name="M:NLog.Targets.MailTarget.#ctor(System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.MailTarget" /> class.
            </summary>
            <remarks>
            The default value of the layout is: <code>${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}</code>
            </remarks>
            <param name="name">Name of the target.</param>
        </member>
        <member name="P:NLog.Targets.MailTarget.SmtpSection">
            <summary>
            Gets the mailSettings/smtp configuration from app.config in cases when we need those configuration.
            E.g when UseSystemNetMailSettings is enabled and we need to read the From attribute from system.net/mailSettings/smtp
            </summary>
            <remarks>Internal for mocking</remarks>
        </member>
        <member name="P:NLog.Targets.MailTarget.From">
            <summary>
            Gets or sets sender's email address (e.g. joe@domain.com).
            </summary>
            <docgen category='Message Options' order='10' />
        </member>
        <member name="P:NLog.Targets.MailTarget.To">
            <summary>
            Gets or sets recipients' email addresses separated by semicolons (e.g. john@domain.com;jane@domain.com).
            </summary>
            <docgen category='Message Options' order='11' />
        </member>
        <member name="P:NLog.Targets.MailTarget.CC">
            <summary>
            Gets or sets CC email addresses separated by semicolons (e.g. john@domain.com;jane@domain.com).
            </summary>
            <docgen category='Message Options' order='12' />
        </member>
        <member name="P:NLog.Targets.MailTarget.Bcc">
            <summary>
            Gets or sets BCC email addresses separated by semicolons (e.g. john@domain.com;jane@domain.com).
            </summary>
            <docgen category='Message Options' order='13' />
        </member>
        <member name="P:NLog.Targets.MailTarget.AddNewLines">
            <summary>
            Gets or sets a value indicating whether to add new lines between log entries.
            </summary>
            <value>A value of <c>true</c> if new lines should be added; otherwise, <c>false</c>.</value>
            <docgen category='Message Options' order='99' />
        </member>
        <member name="P:NLog.Targets.MailTarget.Subject">
            <summary>
            Gets or sets the mail subject.
            </summary>
            <docgen category='Message Options' order='5' />
        </member>
        <member name="P:NLog.Targets.MailTarget.Body">
            <summary>
            Gets or sets mail message body (repeated for each log message send in one mail).
            </summary>
            <remarks>Alias for the <c>Layout</c> property.</remarks>
            <docgen category='Message Options' order='6' />
        </member>
        <member name="P:NLog.Targets.MailTarget.Encoding">
            <summary>
            Gets or sets encoding to be used for sending e-mail.
            </summary>
            <docgen category='Message Options' order='20' />
        </member>
        <member name="P:NLog.Targets.MailTarget.Html">
            <summary>
            Gets or sets a value indicating whether to send message as HTML instead of plain text.
            </summary>
            <docgen category='Message Options' order='11' />
        </member>
        <member name="P:NLog.Targets.MailTarget.SmtpServer">
            <summary>
            Gets or sets SMTP Server to be used for sending.
            </summary>
            <docgen category='SMTP Options' order='10' />
        </member>
        <member name="P:NLog.Targets.MailTarget.SmtpAuthentication">
            <summary>
            Gets or sets SMTP Authentication mode.
            </summary>
            <docgen category='SMTP Options' order='11' />
        </member>
        <member name="P:NLog.Targets.MailTarget.SmtpUserName">
            <summary>
            Gets or sets the username used to connect to SMTP server (used when SmtpAuthentication is set to "basic").
            </summary>
            <docgen category='SMTP Options' order='12' />
        </member>
        <member name="P:NLog.Targets.MailTarget.SmtpPassword">
            <summary>
            Gets or sets the password used to authenticate against SMTP server (used when SmtpAuthentication is set to "basic").
            </summary>
            <docgen category='SMTP Options' order='13' />
        </member>
        <member name="P:NLog.Targets.MailTarget.EnableSsl">
            <summary>
            Gets or sets a value indicating whether SSL (secure sockets layer) should be used when communicating with SMTP server.
            </summary>
            <docgen category='SMTP Options' order='14' />.
        </member>
        <member name="P:NLog.Targets.MailTarget.SmtpPort">
            <summary>
            Gets or sets the port number that SMTP Server is listening on.
            </summary>
            <docgen category='SMTP Options' order='15' />
        </member>
        <member name="P:NLog.Targets.MailTarget.UseSystemNetMailSettings">
            <summary>
            Gets or sets a value indicating whether the default Settings from System.Net.MailSettings should be used.
            </summary>
            <docgen category='SMTP Options' order='16' />
        </member>
        <member name="P:NLog.Targets.MailTarget.DeliveryMethod">
            <summary>
            Specifies how outgoing email messages will be handled.
            </summary>
            <docgen category='SMTP Options' order='18' />
        </member>
        <member name="P:NLog.Targets.MailTarget.PickupDirectoryLocation">
            <summary>
            Gets or sets the folder where applications save mail messages to be processed by the local SMTP server.
            </summary>
            <docgen category='SMTP Options' order='17' />
        </member>
        <member name="P:NLog.Targets.MailTarget.Priority">
            <summary>
            Gets or sets the priority used for sending mails.
            </summary>
            <docgen category='Message Options' order='100' />
        </member>
        <member name="P:NLog.Targets.MailTarget.ReplaceNewlineWithBrTagInHtml">
            <summary>
            Gets or sets a value indicating whether NewLine characters in the body should be replaced with <br/> tags.
            </summary>
            <remarks>Only happens when <see cref="P:NLog.Targets.MailTarget.Html"/> is set to true.</remarks>
            <docgen category='Message Options' order='100' />
        </member>
        <member name="P:NLog.Targets.MailTarget.Timeout">
            <summary>
            Gets or sets a value indicating the SMTP client timeout.
            </summary>
            <remarks>Warning: zero is not infinite waiting</remarks>
            <docgen category='SMTP Options' order='100' />
        </member>
        <member name="P:NLog.Targets.MailTarget.MailHeaders">
            <summary>
            Gets the array of email headers that are transmitted with this email message
            </summary>
            <docgen category='Message Options' order='100' />
        </member>
        <member name="M:NLog.Targets.MailTarget.Write(NLog.Common.AsyncLogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Targets.MailTarget.Write(System.Collections.Generic.IList{NLog.Common.AsyncLogEventInfo})">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Targets.MailTarget.InitializeTarget">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Targets.MailTarget.ProcessSingleMailMessage(System.Collections.Generic.IEnumerable{NLog.Common.AsyncLogEventInfo})">
            <summary>
            Create mail and send with SMTP
            </summary>
            <param name="events">event printed in the body of the event</param>
        </member>
        <member name="M:NLog.Targets.MailTarget.CreateBodyBuffer(System.Collections.Generic.IEnumerable{NLog.Common.AsyncLogEventInfo},NLog.LogEventInfo,NLog.LogEventInfo)">
            <summary>
            Create buffer for body
            </summary>
            <param name="events">all events</param>
            <param name="firstEvent">first event for header</param>
            <param name="lastEvent">last event for footer</param>
            <returns></returns>
        </member>
        <member name="M:NLog.Targets.MailTarget.ConfigureMailClient(NLog.LogEventInfo,NLog.Internal.ISmtpClient)">
            <summary>
            Set properties of <paramref name="client"/>
            </summary>
            <param name="lastEvent">last event for username/password</param>
            <param name="client">client to set properties on</param>
            <remarks>Configure not at <see cref="M:NLog.Targets.MailTarget.InitializeTarget"/>, as the properties could have layout renderers.</remarks>
        </member>
        <member name="M:NLog.Targets.MailTarget.ConvertDirectoryLocation(System.String)">
            <summary>
            Handle <paramref name="pickupDirectoryLocation"/> if it is a virtual directory.
            </summary>
            <param name="pickupDirectoryLocation"></param>
            <returns></returns>
        </member>
        <member name="M:NLog.Targets.MailTarget.GetSmtpSettingsKey(NLog.LogEventInfo)">
            <summary>
            Create key for grouping. Needed for multiple events in one mail message
            </summary>
            <param name="logEvent">event for rendering layouts   </param>
            <returns>string to group on</returns>
        </member>
        <member name="M:NLog.Targets.MailTarget.CreateMailMessage(NLog.LogEventInfo,System.String)">
            <summary>
            Create the mail message with the addresses, properties and body.
            </summary>
        </member>
        <member name="M:NLog.Targets.MailTarget.AddAddresses(System.Net.Mail.MailAddressCollection,NLog.Layouts.Layout,NLog.LogEventInfo)">
            <summary>
            Render  <paramref name="layout"/> and add the addresses to <paramref name="mailAddressCollection"/>
            </summary>
            <param name="mailAddressCollection">Addresses appended to this list</param>
            <param name="layout">layout with addresses, ; separated</param>
            <param name="logEvent">event for rendering the <paramref name="layout"/></param>
            <returns>added a address?</returns>
        </member>
        <member name="T:NLog.Targets.MemoryTarget">
            <summary>
            Writes log messages to <see cref="P:NLog.Targets.MemoryTarget.Logs"/> in memory for programmatic retrieval.
            </summary>
            <remarks>
            <a href="https://github.com/nlog/nlog/wiki/Memory-target">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/nlog/nlog/wiki/Memory-target">Documentation on NLog Wiki</seealso>
            <example>
            <p>
            To set up the target in the <a href="https://github.com/NLog/NLog/wiki/Configuration-file">configuration file</a>,
            use the following syntax:
            </p>
            <code lang="XML" source="examples/targets/Configuration File/Memory/NLog.config" />
            <p>
            To set up the log target programmatically use code like this:
            </p>
            <code lang="C#" source="examples/targets/Configuration API/Memory/Simple/Example.cs" />
            </example>
        </member>
        <member name="M:NLog.Targets.MemoryTarget.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.MemoryTarget" /> class.
            </summary>
            <remarks>
            The default value of the layout is: <code>${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}</code>
            </remarks>
        </member>
        <member name="M:NLog.Targets.MemoryTarget.#ctor(System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.MemoryTarget" /> class.
            </summary>
            <remarks>
            The default value of the layout is: <code>${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}</code>
            </remarks>
            <param name="name">Name of the target.</param>
        </member>
        <member name="P:NLog.Targets.MemoryTarget.Logs">
            <summary>
            Gets the list of logs gathered in the <see cref="T:NLog.Targets.MemoryTarget"/>.
            </summary>
            <remarks>
            Be careful when enumerating, as NLog target is blocked from writing during enumeration (blocks application logging)
            </remarks>
        </member>
        <member name="P:NLog.Targets.MemoryTarget.MaxLogsCount">
            <summary>
            Gets or sets the max number of items to have in memory
            </summary>
            <docgen category='Buffering Options' order='10' />
        </member>
        <member name="M:NLog.Targets.MemoryTarget.InitializeTarget">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Targets.MemoryTarget.CloseTarget">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Targets.MemoryTarget.Write(NLog.LogEventInfo)">
            <summary>
            Renders the logging event message and adds to <see cref="P:NLog.Targets.MemoryTarget.Logs"/>
            </summary>
            <param name="logEvent">The logging event.</param>
        </member>
        <member name="T:NLog.Targets.MethodCallParameter">
            <summary>
            A parameter to MethodCall.
            </summary>
        </member>
        <member name="M:NLog.Targets.MethodCallParameter.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.MethodCallParameter" /> class.
            </summary>
        </member>
        <member name="M:NLog.Targets.MethodCallParameter.#ctor(NLog.Layouts.Layout)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.MethodCallParameter" /> class.
            </summary>
            <param name="layout">The layout to use for parameter value.</param>
        </member>
        <member name="M:NLog.Targets.MethodCallParameter.#ctor(System.String,NLog.Layouts.Layout)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.MethodCallParameter" /> class.
            </summary>
            <param name="parameterName">Name of the parameter.</param>
            <param name="layout">The layout.</param>
        </member>
        <member name="M:NLog.Targets.MethodCallParameter.#ctor(System.String,NLog.Layouts.Layout,System.Type)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.MethodCallParameter" /> class.
            </summary>
            <param name="name">The name of the parameter.</param>
            <param name="layout">The layout.</param>
            <param name="type">The type of the parameter.</param>
        </member>
        <member name="P:NLog.Targets.MethodCallParameter.Name">
            <summary>
            Gets or sets the name of the parameter.
            </summary>
            <docgen category='Parameter Options' order='1' />
        </member>
        <member name="P:NLog.Targets.MethodCallParameter.Layout">
            <summary>
            Gets or sets the layout that should be use to calculate the value for the parameter.
            </summary>
            <docgen category='Parameter Options' order='10' />
        </member>
        <member name="P:NLog.Targets.MethodCallParameter.Type">
            <summary>
            Obsolete and replaced by <see cref="P:NLog.Targets.MethodCallParameter.ParameterType"/> with NLog v4.6.
            Gets or sets the type of the parameter. Obsolete alias for <see cref="P:NLog.Targets.MethodCallParameter.ParameterType"/>
            </summary>
            <docgen category='Parameter Options' order='50' />
        </member>
        <member name="P:NLog.Targets.MethodCallParameter.ParameterType">
            <summary>
            Gets or sets the type of the parameter.
            </summary>
            <docgen category='Parameter Options' order='50' />
        </member>
        <member name="P:NLog.Targets.MethodCallParameter.DefaultValue">
            <summary>
            Gets or sets the fallback value when result value is not available
            </summary>
            <docgen category='Parameter Options' order='50' />
        </member>
        <member name="M:NLog.Targets.MethodCallParameter.RenderValue(NLog.LogEventInfo)">
            <summary>
            Render Result Value
            </summary>
            <param name="logEvent">Log event for rendering</param>
            <returns>Result value when available, else fallback to defaultValue</returns>
        </member>
        <member name="T:NLog.Targets.MethodCallTarget">
            <summary>
            Calls the specified static method on each log message and passes contextual parameters to it.
            </summary>
            <remarks>
            <a href="https://github.com/nlog/nlog/wiki/MethodCall-target">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/nlog/nlog/wiki/MethodCall-target">Documentation on NLog Wiki</seealso>
            <example>
            <p>
            To set up the target in the <a href="https://github.com/NLog/NLog/wiki/Configuration-file">configuration file</a>,
            use the following syntax:
            </p>
            <code lang="XML" source="examples/targets/Configuration File/MethodCall/NLog.config" />
            <p>
            To set up the log target programmatically use code like this:
            </p>
            <code lang="C#" source="examples/targets/Configuration API/MethodCall/Simple/Example.cs" />
            </example>
        </member>
        <member name="P:NLog.Targets.MethodCallTarget.ClassName">
            <summary>
            Gets or sets the class name.
            </summary>
            <docgen category='Invocation Options' order='10' />
        </member>
        <member name="P:NLog.Targets.MethodCallTarget.MethodName">
             <summary>
             Gets or sets the method name. The method must be public and static.
            
             Use the AssemblyQualifiedName , https://msdn.microsoft.com/en-us/library/system.type.assemblyqualifiedname(v=vs.110).aspx
             e.g.
             </summary>
             <docgen category='Invocation Options' order='10' />
        </member>
        <member name="M:NLog.Targets.MethodCallTarget.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.MethodCallTarget" /> class.
            </summary>
        </member>
        <member name="M:NLog.Targets.MethodCallTarget.#ctor(System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.MethodCallTarget" /> class.
            </summary>
            <param name="name">Name of the target.</param>
        </member>
        <member name="M:NLog.Targets.MethodCallTarget.#ctor(System.String,System.Action{NLog.LogEventInfo,System.Object[]})">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.MethodCallTarget" /> class.
            </summary>
            <param name="name">Name of the target.</param>
            <param name="logEventAction">Method to call on logevent.</param>
        </member>
        <member name="M:NLog.Targets.MethodCallTarget.InitializeTarget">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Targets.MethodCallTarget.DoInvoke(System.Object[],NLog.Common.AsyncLogEventInfo)">
            <summary>
            Calls the specified Method.
            </summary>
            <param name="parameters">Method parameters.</param>
            <param name="logEvent">The logging event.</param>
        </member>
        <member name="M:NLog.Targets.MethodCallTarget.DoInvoke(System.Object[])">
            <summary>
            Calls the specified Method.
            </summary>
            <param name="parameters">Method parameters.</param>
        </member>
        <member name="T:NLog.Targets.MethodCallTargetBase">
            <summary>
            The base class for all targets which call methods (local or remote).
            Manages parameters and type coercion.
            </summary>
        </member>
        <member name="M:NLog.Targets.MethodCallTargetBase.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.MethodCallTargetBase" /> class.
            </summary>
        </member>
        <member name="P:NLog.Targets.MethodCallTargetBase.Parameters">
            <summary>
            Gets the array of parameters to be passed.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="M:NLog.Targets.MethodCallTargetBase.Write(NLog.Common.AsyncLogEventInfo)">
            <summary>
            Prepares an array of parameters to be passed based on the logging event and calls DoInvoke().
            </summary>
            <param name="logEvent">The logging event.</param>
        </member>
        <member name="M:NLog.Targets.MethodCallTargetBase.DoInvoke(System.Object[],NLog.Common.AsyncLogEventInfo)">
            <summary>
            Calls the target DoInvoke method, and handles AsyncContinuation callback
            </summary>
            <param name="parameters">Method call parameters.</param>
            <param name="logEvent">The logging event.</param>
        </member>
        <member name="M:NLog.Targets.MethodCallTargetBase.DoInvoke(System.Object[],NLog.Common.AsyncContinuation)">
            <summary>
            Calls the target DoInvoke method, and handles AsyncContinuation callback
            </summary>
            <param name="parameters">Method call parameters.</param>
            <param name="continuation">The continuation.</param>
        </member>
        <member name="M:NLog.Targets.MethodCallTargetBase.DoInvoke(System.Object[])">
            <summary>
            Calls the target method. Must be implemented in concrete classes.
            </summary>
            <param name="parameters">Method call parameters.</param>
        </member>
        <member name="T:NLog.Targets.NetworkLogEventDroppedEventArgs">
            <summary>
            Arguments for <see cref="E:NLog.Targets.NetworkTarget.LogEventDropped"/> events.
            </summary>
        </member>
        <member name="F:NLog.Targets.NetworkLogEventDroppedEventArgs.MaxMessageSizeOverflow">
            <inheritdoc cref="F:NLog.Targets.NetworkLogEventDroppedReason.MaxMessageSizeOverflow"/>
        </member>
        <member name="F:NLog.Targets.NetworkLogEventDroppedEventArgs.MaxConnectionsOverflow">
            <inheritdoc cref="F:NLog.Targets.NetworkLogEventDroppedReason.MaxConnectionsOverflow"/>
        </member>
        <member name="F:NLog.Targets.NetworkLogEventDroppedEventArgs.MaxQueueOverflow">
            <inheritdoc cref="F:NLog.Targets.NetworkLogEventDroppedReason.MaxQueueOverflow"/>
        </member>
        <member name="F:NLog.Targets.NetworkLogEventDroppedEventArgs.NetworkErrorDetected">
            <inheritdoc cref="F:NLog.Targets.NetworkLogEventDroppedReason.NetworkError"/>
        </member>
        <member name="M:NLog.Targets.NetworkLogEventDroppedEventArgs.#ctor(NLog.Targets.NetworkLogEventDroppedReason)">
            <summary>
            Creates new instance of NetworkTargetLogEventDroppedEventArgs
            </summary>
        </member>
        <member name="P:NLog.Targets.NetworkLogEventDroppedEventArgs.Reason">
            <summary>
            The reason why log was dropped
            </summary>
        </member>
        <member name="T:NLog.Targets.NetworkLogEventDroppedReason">
            <summary>
            The reason why log event was dropped by <see cref="T:NLog.Targets.NetworkTarget"/>
            </summary>
        </member>
        <member name="F:NLog.Targets.NetworkLogEventDroppedReason.MaxMessageSizeOverflow">
            <summary>
            Discarded LogEvent because message is bigger than <see cref="P:NLog.Targets.NetworkTarget.MaxMessageSize"/>
            </summary>
        </member>
        <member name="F:NLog.Targets.NetworkLogEventDroppedReason.MaxQueueOverflow">
            <summary>
            Discarded LogEvent because message queue was bigger than <see cref="P:NLog.Targets.NetworkTarget.MaxQueueSize"/>
            </summary>
        </member>
        <member name="F:NLog.Targets.NetworkLogEventDroppedReason.MaxConnectionsOverflow">
            <summary>
            Discarded LogEvent because attempted to open more than <see cref="P:NLog.Targets.NetworkTarget.MaxConnections"/> connections
            </summary>
        </member>
        <member name="F:NLog.Targets.NetworkLogEventDroppedReason.NetworkError">
            <summary>
            Discarded LogEvent because of network communication error
            </summary>
        </member>
        <member name="T:NLog.Targets.NetworkTarget">
            <summary>
            NetworkTarget for sending messages over the network using TCP / UDP sockets
            </summary>
            <remarks>
            <a href="https://github.com/nlog/nlog/wiki/Network-target">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/nlog/nlog/wiki/Network-target">Documentation on NLog Wiki</seealso>
            <example>
            <p>
            To set up the target in the <a href="https://github.com/NLog/NLog/wiki/Configuration-file">configuration file</a>,
            use the following syntax:
            </p>
            <code lang="XML" source="examples/targets/Configuration File/Network/NLog.config" />
            <p>
            To set up the log target programmatically use code like this:
            </p>
            <code lang="C#" source="examples/targets/Configuration API/Network/Simple/Example.cs" />
            <p>
            To print the results, use any application that's able to receive messages over
            TCP or UDP. <a href="http://m.nu/program/util/netcat/netcat.html">NetCat</a> is
            a simple but very powerful command-line tool that can be used for that. This image
            demonstrates the NetCat tool receiving log messages from Network target.
            </p>
            <img src="examples/targets/Screenshots/Network/Output.gif" />
            <p>
            There are two specialized versions of the Network target: <a href="T_NLog_Targets_ChainsawTarget.htm">Chainsaw</a>
            and <a href="T_NLog_Targets_NLogViewerTarget.htm">NLogViewer</a> which write to instances of Chainsaw log4j viewer
            or NLogViewer application respectively.
            </p>
            </example>
        </member>
        <member name="M:NLog.Targets.NetworkTarget.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.NetworkTarget" /> class.
            </summary>
            <remarks>
            The default value of the layout is: <code>${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}</code>
            </remarks>
        </member>
        <member name="M:NLog.Targets.NetworkTarget.#ctor(System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.NetworkTarget" /> class.
            </summary>
            <remarks>
            The default value of the layout is: <code>${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}</code>
            </remarks>
            <param name="name">Name of the target.</param>
        </member>
        <member name="P:NLog.Targets.NetworkTarget.Address">
            <summary>
            Gets or sets the network address.
            </summary>
            <remarks>
            The network address can be:
            <ul>
            <li>tcp://host:port - TCP (auto select IPv4/IPv6)</li>
            <li>tcp4://host:port - force TCP/IPv4</li>
            <li>tcp6://host:port - force TCP/IPv6</li>
            <li>udp://host:port - UDP (auto select IPv4/IPv6)</li>
            <li>udp4://host:port - force UDP/IPv4</li>
            <li>udp6://host:port - force UDP/IPv6</li>
            <li>http://host:port/pageName - HTTP using POST verb</li>
            <li>https://host:port/pageName - HTTPS using POST verb</li>
            </ul>
            For SOAP-based webservice support over HTTP use WebService target.
            </remarks>
            <docgen category='Connection Options' order='10' />
        </member>
        <member name="P:NLog.Targets.NetworkTarget.KeepConnection">
            <summary>
            Gets or sets a value indicating whether to keep connection open whenever possible.
            </summary>
            <docgen category='Connection Options' order='10' />
        </member>
        <member name="P:NLog.Targets.NetworkTarget.NewLine">
            <summary>
            Gets or sets a value indicating whether to append newline at the end of log message.
            </summary>
            <docgen category='Payload Options' order='10' />
        </member>
        <member name="P:NLog.Targets.NetworkTarget.LineEnding">
            <summary>
            Gets or sets the end of line value if a newline is appended at the end of log message <see cref="P:NLog.Targets.NetworkTarget.NewLine"/>.
            </summary>
            <docgen category='Payload Options' order='10' />
        </member>
        <member name="P:NLog.Targets.NetworkTarget.MaxMessageSize">
            <summary>
            Gets or sets the maximum message size in bytes. On limit breach then <see cref="P:NLog.Targets.NetworkTarget.OnOverflow"/> action is activated.
            </summary>
            <docgen category='Payload Options' order='10' />
        </member>
        <member name="P:NLog.Targets.NetworkTarget.MaxConnections">
            <summary>
            Gets or sets the maximum simultaneous connections. Requires <see cref="P:NLog.Targets.NetworkTarget.KeepConnection"/> = false
            </summary>
            <remarks>
            When having reached the maximum limit, then <see cref="P:NLog.Targets.NetworkTarget.OnConnectionOverflow"/> action will apply.
            </remarks>
            <docgen category="Connection Options" order="10"/>
        </member>
        <member name="P:NLog.Targets.NetworkTarget.OnConnectionOverflow">
            <summary>
            Gets or sets the action that should be taken, when more connections than <see cref="P:NLog.Targets.NetworkTarget.MaxConnections"/>.
            </summary>
            <docgen category='Connection Options' order='10' />
        </member>
        <member name="P:NLog.Targets.NetworkTarget.MaxQueueSize">
            <summary>
            Gets or sets the maximum queue size for a single connection. Requires <see cref="P:NLog.Targets.NetworkTarget.KeepConnection"/> = true
            </summary>
            <remarks>
            When having reached the maximum limit, then <see cref="P:NLog.Targets.NetworkTarget.OnQueueOverflow"/> action will apply.
            </remarks>
            <docgen category='Connection Options' order='10' />
        </member>
        <member name="P:NLog.Targets.NetworkTarget.OnQueueOverflow">
            <summary>
            Gets or sets the action that should be taken, when more pending messages than <see cref="P:NLog.Targets.NetworkTarget.MaxQueueSize"/>.
            </summary>
            <docgen category='Connection Options' order='10' />
        </member>
        <member name="E:NLog.Targets.NetworkTarget.LogEventDropped">
            <summary>
            Occurs when LogEvent has been dropped.
            </summary>
            <remarks>
             - When internal queue is full and <see cref="P:NLog.Targets.NetworkTarget.OnQueueOverflow"/> set to <see cref="F:NLog.Targets.NetworkTargetOverflowAction.Discard"/><br/>
             - When connection-list is full and <see cref="P:NLog.Targets.NetworkTarget.OnConnectionOverflow"/> set to <see cref="F:NLog.Targets.NetworkTargetConnectionsOverflowAction.Discard"/><br/>
             - When message is too big and <see cref="P:NLog.Targets.NetworkTarget.OnOverflow"/> set to <see cref="F:NLog.Targets.NetworkTargetOverflowAction.Discard"/><br/>
            </remarks>
        </member>
        <member name="P:NLog.Targets.NetworkTarget.ConnectionCacheSize">
            <summary>
            Gets or sets the size of the connection cache (number of connections which are kept alive). Requires <see cref="P:NLog.Targets.NetworkTarget.KeepConnection"/> = true
            </summary>
            <docgen category="Connection Options" order="10"/>
        </member>
        <member name="P:NLog.Targets.NetworkTarget.OnOverflow">
             <summary>
             Gets or sets the action that should be taken if the message is larger than <see cref="P:NLog.Targets.NetworkTarget.MaxMessageSize" />
             </summary>
             <remarks>
             For TCP sockets then <see cref="F:NLog.Targets.NetworkTargetOverflowAction.Split"/> means no-limit, as TCP sockets
             performs splitting automatically.
            
             For UDP Network sender then <see cref="F:NLog.Targets.NetworkTargetOverflowAction.Split"/> means splitting the message
             into smaller chunks. This can be useful on networks using DontFragment, which drops network packages
             larger than MTU-size (1472 bytes).
             </remarks>
             <docgen category='Connection Options' order='10' />
        </member>
        <member name="P:NLog.Targets.NetworkTarget.Encoding">
            <summary>
            Gets or sets the encoding to be used.
            </summary>
            <docgen category='Payload Options' order='10' />
        </member>
        <member name="P:NLog.Targets.NetworkTarget.SslProtocols">
            <summary>
            Gets or sets the SSL/TLS protocols. Default no SSL/TLS is used. Currently only implemented for TCP.
            </summary>
            <docgen category='Connection Options' order='10' />
        </member>
        <member name="P:NLog.Targets.NetworkTarget.KeepAliveTimeSeconds">
            <summary>
            The number of seconds a connection will remain idle before the first keep-alive probe is sent
            </summary>
            <docgen category='Connection Options' order='10' />
        </member>
        <member name="P:NLog.Targets.NetworkTarget.SendTimeoutSeconds">
            <summary>
            The number of seconds a TCP socket send-operation will block before timeout error. Default wait forever when network cable unplugged and tcp-buffer becomes full.
            </summary>
            <docgen category='Connection Options' order='10' />
        </member>
        <member name="P:NLog.Targets.NetworkTarget.Compress">
            <summary>
            Type of compression for protocol payload. Useful for UDP where datagram max-size is 8192 bytes.
            </summary>
        </member>
        <member name="P:NLog.Targets.NetworkTarget.CompressMinBytes">
            <summary>
            Skip compression when protocol payload is below limit to reduce overhead in cpu-usage and additional headers
            </summary>
        </member>
        <member name="M:NLog.Targets.NetworkTarget.FlushAsync(NLog.Common.AsyncContinuation)">
            <summary>
            Flush any pending log messages asynchronously (in case of asynchronous targets).
            </summary>
            <param name="asyncContinuation">The asynchronous continuation.</param>
        </member>
        <member name="M:NLog.Targets.NetworkTarget.CloseTarget">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Targets.NetworkTarget.Write(NLog.Common.AsyncLogEventInfo)">
            <summary>
            Sends the
            rendered logging event over the network optionally concatenating it with a newline character.
            </summary>
            <param name="logEvent">The logging event.</param>
        </member>
        <member name="M:NLog.Targets.NetworkTarget.TryRemove``1(System.Collections.Generic.LinkedList{``0},System.Collections.Generic.LinkedListNode{``0})">
            <summary>
            Try to remove.
            </summary>
            <typeparam name="T"></typeparam>
            <param name="list"></param>
            <param name="node"></param>
            <returns>removed something?</returns>
        </member>
        <member name="M:NLog.Targets.NetworkTarget.GetBytesToWrite(NLog.LogEventInfo)">
            <summary>
            Gets the bytes to be written.
            </summary>
            <param name="logEvent">Log event.</param>
            <returns>Byte array.</returns>
        </member>
        <member name="T:NLog.Targets.NetworkTargetCompressionType">
            <summary>
            Type of compression for protocol payload
            </summary>
        </member>
        <member name="F:NLog.Targets.NetworkTargetCompressionType.None">
            <summary>
            No compression
            </summary>
        </member>
        <member name="F:NLog.Targets.NetworkTargetCompressionType.GZip">
            <summary>
            GZip optimal compression
            </summary>
        </member>
        <member name="F:NLog.Targets.NetworkTargetCompressionType.GZipFast">
            <summary>
            GZip fastest compression
            </summary>
        </member>
        <member name="T:NLog.Targets.NetworkTargetConnectionsOverflowAction">
            <summary>
            The action to be taken when there are more connections then the max.
            </summary>
        </member>
        <member name="F:NLog.Targets.NetworkTargetConnectionsOverflowAction.Grow">
            <summary>
            Allow new connections when reaching max connection limit
            </summary>
        </member>
        <member name="F:NLog.Targets.NetworkTargetConnectionsOverflowAction.AllowNewConnnection">
            <summary>
            Obsolete and replaced by <see cref="F:NLog.Targets.NetworkTargetConnectionsOverflowAction.Grow"/> with NLog v5.
            Just allow it.
            </summary>
        </member>
        <member name="F:NLog.Targets.NetworkTargetConnectionsOverflowAction.Discard">
            <summary>
            Discard new messages when reaching max connection limit
            </summary>
        </member>
        <member name="F:NLog.Targets.NetworkTargetConnectionsOverflowAction.DiscardMessage">
            <summary>
            Obsolete and replaced by <see cref="F:NLog.Targets.NetworkTargetConnectionsOverflowAction.Discard"/> with NLog v5.
            Discard the connection item.
            </summary>
        </member>
        <member name="F:NLog.Targets.NetworkTargetConnectionsOverflowAction.Block">
            <summary>
            Block until there's more room in the queue.
            </summary>
        </member>
        <member name="T:NLog.Targets.NetworkTargetOverflowAction">
            <summary>
            Action that should be taken if the message overflows.
            </summary>
        </member>
        <member name="F:NLog.Targets.NetworkTargetOverflowAction.Error">
            <summary>
            Report an error.
            </summary>
        </member>
        <member name="F:NLog.Targets.NetworkTargetOverflowAction.Split">
            <summary>
            Split the message into smaller pieces. Only relevant for UDP sockets, as TCP sockets does it automatically.
            </summary>
            <remarks>
            Udp-Network-Sender will split the message into smaller chunks that matches <see cref="P:NLog.Targets.NetworkTarget.MaxMessageSize"/>.
            This can avoid network-package-drop when network uses DontFragment and message is larger than MTU-size (1472 bytes).
            </remarks>
        </member>
        <member name="F:NLog.Targets.NetworkTargetOverflowAction.Discard">
            <summary>
            Discard the entire message.
            </summary>
        </member>
        <member name="T:NLog.Targets.NetworkTargetQueueOverflowAction">
            <summary>
            The action to be taken when the queue overflows.
            </summary>
        </member>
        <member name="F:NLog.Targets.NetworkTargetQueueOverflowAction.Grow">
            <summary>
            Grow the queue.
            </summary>
        </member>
        <member name="F:NLog.Targets.NetworkTargetQueueOverflowAction.Discard">
            <summary>
            Discard the overflowing item.
            </summary>
        </member>
        <member name="F:NLog.Targets.NetworkTargetQueueOverflowAction.Block">
            <summary>
            Block until there's more room in the queue.
            </summary>
        </member>
        <member name="T:NLog.Targets.NLogViewerParameterInfo">
            <summary>
            Represents a parameter to a NLogViewer target.
            </summary>
        </member>
        <member name="M:NLog.Targets.NLogViewerParameterInfo.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.NLogViewerParameterInfo" /> class.
            </summary>
        </member>
        <member name="P:NLog.Targets.NLogViewerParameterInfo.Name">
            <summary>
            Gets or sets viewer parameter name.
            </summary>
            <docgen category='Layout Options' order='1' />
        </member>
        <member name="P:NLog.Targets.NLogViewerParameterInfo.Layout">
            <summary>
            Gets or sets the layout that should be use to calculate the value for the parameter.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Targets.NLogViewerParameterInfo.IncludeEmptyValue">
            <summary>
            Gets or sets whether an attribute with empty value should be included in the output
            </summary>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="T:NLog.Targets.NLogViewerTarget">
            <summary>
            Sends log messages to the remote instance of NLog Viewer.
            </summary>
            <remarks>
            <a href="https://github.com/nlog/nlog/wiki/NLogViewer-target">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/nlog/nlog/wiki/NLogViewer-target">Documentation on NLog Wiki</seealso>
            <example>
            <p>
            To set up the target in the <a href="https://github.com/NLog/NLog/wiki/Configuration-file">configuration file</a>,
            use the following syntax:
            </p>
            <code lang="XML" source="examples/targets/Configuration File/NLogViewer/NLog.config" />
            <p>
            To set up the log target programmatically use code like this:
            </p>
            <code lang="C#" source="examples/targets/Configuration API/NLogViewer/Simple/Example.cs" />
            </example>
        </member>
        <member name="M:NLog.Targets.NLogViewerTarget.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.NLogViewerTarget" /> class.
            </summary>
            <remarks>
            The default value of the layout is: <code>${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}</code>
            </remarks>
        </member>
        <member name="M:NLog.Targets.NLogViewerTarget.#ctor(System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.NLogViewerTarget" /> class.
            </summary>
            <remarks>
            The default value of the layout is: <code>${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}</code>
            </remarks>
            <param name="name">Name of the target.</param>
        </member>
        <member name="P:NLog.Targets.NLogViewerTarget.IncludeNLogData">
            <summary>
            Gets or sets a value indicating whether to include NLog-specific extensions to log4j schema.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Targets.NLogViewerTarget.LoggerName">
            <summary>
            Gets or sets the log4j:event logger-xml-attribute. Default: ${logger}
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Targets.NLogViewerTarget.FormattedMessage">
            <summary>
            Gets or sets the log4j:event message-xml-element. Default: ${message}
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Targets.NLogViewerTarget.AppInfo">
            <summary>
            Gets or sets the log4j:event log4japp-xml-element. By default it's the friendly name of the current AppDomain.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Targets.NLogViewerTarget.IncludeCallSite">
            <summary>
            Gets or sets a value indicating whether to include call site (class and method name) in the information sent over the network.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Targets.NLogViewerTarget.IncludeSourceInfo">
            <summary>
            Gets or sets a value indicating whether to include source info (file name and line number) in the information sent over the network.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Targets.NLogViewerTarget.IncludeMdc">
            <summary>
            Obsolete and replaced by <see cref="P:NLog.Targets.NLogViewerTarget.IncludeScopeProperties"/> with NLog v5.
            Gets or sets a value indicating whether to include <see cref="T:NLog.MappedDiagnosticsContext"/> dictionary contents.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Targets.NLogViewerTarget.IncludeNdc">
            <summary>
            Gets or sets whether to include log4j:NDC in output from <see cref="T:NLog.ScopeContext"/> nested context.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Targets.NLogViewerTarget.IncludeEventProperties">
            <summary>
            Gets or sets the option to include all properties from the log events
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Targets.NLogViewerTarget.IncludeScopeProperties">
            <summary>
            Gets or sets whether to include the contents of the <see cref="T:NLog.ScopeContext"/> properties-dictionary.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Targets.NLogViewerTarget.IncludeScopeNested">
            <summary>
            Gets or sets whether to include log4j:NDC in output from <see cref="T:NLog.ScopeContext"/> nested context.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Targets.NLogViewerTarget.ScopeNestedSeparator">
            <summary>
            Gets or sets the separator for <see cref="T:NLog.ScopeContext"/> operation-states-stack.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Targets.NLogViewerTarget.IncludeAllProperties">
            <summary>
            Obsolete and replaced by <see cref="P:NLog.Targets.NLogViewerTarget.IncludeEventProperties"/> with NLog v5.
            Gets or sets the option to include all properties from the log events
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Targets.NLogViewerTarget.IncludeMdlc">
            <summary>
            Obsolete and replaced by <see cref="P:NLog.Targets.NLogViewerTarget.IncludeScopeProperties"/> with NLog v5.
            Gets or sets a value indicating whether to include <see cref="T:NLog.MappedDiagnosticsLogicalContext"/> dictionary contents.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Targets.NLogViewerTarget.IncludeNdlc">
            <summary>
            Obsolete and replaced by <see cref="P:NLog.Targets.NLogViewerTarget.IncludeNdc"/> with NLog v5.
            Gets or sets a value indicating whether to include contents of the <see cref="T:NLog.NestedDiagnosticsLogicalContext"/> stack.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Targets.NLogViewerTarget.NdlcItemSeparator">
            <summary>
            Obsolete and replaced by <see cref="P:NLog.Targets.NLogViewerTarget.NdcItemSeparator"/> with NLog v5.
            Gets or sets the stack separator for log4j:NDC in output from <see cref="T:NLog.ScopeContext"/> nested context.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Targets.NLogViewerTarget.NdcItemSeparator">
            <summary>
            Gets or sets the stack separator for log4j:NDC in output from <see cref="T:NLog.ScopeContext"/> nested context.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Targets.NLogViewerTarget.Parameters">
            <summary>
            Gets the collection of parameters. Each parameter contains a mapping
            between NLog layout and a named parameter.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Targets.NLogViewerTarget.Renderer">
            <summary>
            Gets the layout renderer which produces Log4j-compatible XML events.
            </summary>
        </member>
        <member name="P:NLog.Targets.NLogViewerTarget.Layout">
            <summary>
            Gets or sets the instance of <see cref="T:NLog.Layouts.Log4JXmlEventLayout"/> that is used to format log messages.
            </summary>
            <docgen category='Layout Options' order='1' />
        </member>
        <member name="T:NLog.Targets.NullTarget">
            <summary>
            Discards log messages. Used mainly for debugging and benchmarking.
            </summary>
            <remarks>
            <a href="https://github.com/nlog/nlog/wiki/Null-target">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/nlog/nlog/wiki/Null-target">Documentation on NLog Wiki</seealso>
            <example>
            <p>
            To set up the target in the <a href="https://github.com/NLog/NLog/wiki/Configuration-file">configuration file</a>,
            use the following syntax:
            </p>
            <code lang="XML" source="examples/targets/Configuration File/Null/NLog.config" />
            <p>
            To set up the log target programmatically use code like this:
            </p>
            <code lang="C#" source="examples/targets/Configuration API/Null/Simple/Example.cs" />
            </example>
        </member>
        <member name="P:NLog.Targets.NullTarget.FormatMessage">
            <summary>
            Gets or sets a value indicating whether to perform layout calculation.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="M:NLog.Targets.NullTarget.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.NullTarget" /> class.
            </summary>
        </member>
        <member name="M:NLog.Targets.NullTarget.#ctor(System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.NullTarget" /> class.
            </summary>
            <param name="name">Name of the target.</param>
        </member>
        <member name="M:NLog.Targets.NullTarget.Write(NLog.LogEventInfo)">
            <summary>
            Does nothing. Optionally it calculates the layout text but
            discards the results.
            </summary>
            <param name="logEvent">The logging event.</param>
        </member>
        <member name="T:NLog.Targets.SmtpAuthenticationMode">
            <summary>
            SMTP authentication modes.
            </summary>
        </member>
        <member name="F:NLog.Targets.SmtpAuthenticationMode.None">
            <summary>
            No authentication.
            </summary>
        </member>
        <member name="F:NLog.Targets.SmtpAuthenticationMode.Basic">
            <summary>
            Basic - username and password.
            </summary>
        </member>
        <member name="F:NLog.Targets.SmtpAuthenticationMode.Ntlm">
            <summary>
            NTLM Authentication.
            </summary>
        </member>
        <member name="T:NLog.Targets.Target">
            <summary>
            Represents logging target.
            </summary>
        </member>
        <member name="F:NLog.Targets.Target._allLayoutsAreThreadAgnostic">
            <summary> Are all layouts in this target thread-agnostic, if so we don't precalculate the layouts </summary>
        </member>
        <member name="P:NLog.Targets.Target.StackTraceUsage">
            <summary>
            The Max StackTraceUsage of all the <see cref="T:NLog.Layouts.Layout"/> in this Target
            </summary>
        </member>
        <member name="P:NLog.Targets.Target.Name">
            <summary>
            Gets or sets the name of the target.
            </summary>
            <docgen category='General Options' order='1' />
        </member>
        <member name="P:NLog.Targets.Target.OptimizeBufferReuse">
            <summary>
            Target supports reuse of internal buffers, and doesn't have to constantly allocate new buffers
            Required for legacy NLog-targets, that expects buffers to remain stable after Write-method exit
            </summary>
            <docgen category='Performance Tuning Options' order='10' />
        </member>
        <member name="P:NLog.Targets.Target.LayoutWithLock">
             <summary>
             NLog Layout are by default threadsafe, so multiple threads can be rendering logevents at the same time.
             This ensure high concurrency with no lock-congestion for the application-threads, especially when using <see cref="T:NLog.Targets.Wrappers.AsyncTargetWrapper"/>
             or AsyncTaskTarget.
            
             But if using custom <see cref="T:NLog.Layouts.Layout" /> or <see cref="T:NLog.LayoutRenderers.LayoutRenderer"/> that are not
             threadsafe, then this option can enabled to protect against thread-concurrency-issues. Allowing one
             to update to NLog 5.0 without having to fix custom/external layout-dependencies.
             </summary>
             <docgen category='Performance Tuning Options' order='10' />
        </member>
        <member name="P:NLog.Targets.Target.SyncRoot">
            <summary>
            Gets the object which can be used to synchronize asynchronous operations that must rely on the .
            </summary>
        </member>
        <member name="P:NLog.Targets.Target.LoggingConfiguration">
            <summary>
            Gets the logging configuration this target is part of.
            </summary>
        </member>
        <member name="P:NLog.Targets.Target.IsInitialized">
            <summary>
            Gets a value indicating whether the target has been initialized.
            </summary>
        </member>
        <member name="M:NLog.Targets.Target.NLog#Internal#ISupportsInitialize#Initialize(NLog.Config.LoggingConfiguration)">
            <summary>
            Initializes this instance.
            </summary>
            <param name="configuration">The configuration.</param>
        </member>
        <member name="M:NLog.Targets.Target.NLog#Internal#ISupportsInitialize#Close">
            <summary>
            Closes this instance.
            </summary>
        </member>
        <member name="M:NLog.Targets.Target.Dispose">
            <summary>
            Closes the target.
            </summary>
        </member>
        <member name="M:NLog.Targets.Target.Flush(NLog.Common.AsyncContinuation)">
            <summary>
            Flush any pending log messages (in case of asynchronous targets).
            </summary>
            <param name="asyncContinuation">The asynchronous continuation.</param>
        </member>
        <member name="M:NLog.Targets.Target.PrecalculateVolatileLayouts(NLog.LogEventInfo)">
            <summary>
            Calls the <see cref="M:NLog.Layouts.Layout.Precalculate(NLog.LogEventInfo)"/> on each volatile layout
            used by this target.
            This method won't prerender if all layouts in this target are thread-agnostic.
            </summary>
            <param name="logEvent">
            The log event.
            </param>
        </member>
        <member name="M:NLog.Targets.Target.ToString">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Targets.Target.WriteAsyncLogEvent(NLog.Common.AsyncLogEventInfo)">
            <summary>
            Writes the log to the target.
            </summary>
            <param name="logEvent">Log event to write.</param>
        </member>
        <member name="M:NLog.Targets.Target.WriteAsyncLogEvents(NLog.Common.AsyncLogEventInfo[])">
            <summary>
            Writes the array of log events.
            </summary>
            <param name="logEvents">The log events.</param>
        </member>
        <member name="M:NLog.Targets.Target.WriteAsyncLogEvents(System.Collections.Generic.IList{NLog.Common.AsyncLogEventInfo})">
            <summary>
            Writes the array of log events.
            </summary>
            <param name="logEvents">The log events.</param>
        </member>
        <member name="M:NLog.Targets.Target.WriteFailedNotInitialized(NLog.Common.AsyncLogEventInfo,System.Exception)">
            <summary>
            LogEvent is written to target, but target failed to successfully initialize
            </summary>
        </member>
        <member name="M:NLog.Targets.Target.Initialize(NLog.Config.LoggingConfiguration)">
            <summary>
            Initializes this instance.
            </summary>
            <param name="configuration">The configuration.</param>
        </member>
        <member name="M:NLog.Targets.Target.Close">
            <summary>
            Closes this instance.
            </summary>
        </member>
        <member name="M:NLog.Targets.Target.Dispose(System.Boolean)">
            <summary>
            Releases unmanaged and - optionally - managed resources.
            </summary>
            <param name="disposing">True to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
        </member>
        <member name="M:NLog.Targets.Target.InitializeTarget">
            <summary>
            Initializes the target before writing starts
            </summary>
        </member>
        <member name="M:NLog.Targets.Target.CloseTarget">
            <summary>
            Closes the target to release any initialized resources
            </summary>
        </member>
        <member name="M:NLog.Targets.Target.FlushAsync(NLog.Common.AsyncContinuation)">
            <summary>
            Flush any pending log messages
            </summary>
            <remarks>The asynchronous continuation parameter must be called on flush completed</remarks>
            <param name="asyncContinuation">The asynchronous continuation to be called on flush completed.</param>
        </member>
        <member name="M:NLog.Targets.Target.Write(NLog.LogEventInfo)">
            <summary>
            Writes logging event to the target destination
            </summary>
            <param name="logEvent">Logging event to be written out.</param>
        </member>
        <member name="M:NLog.Targets.Target.Write(NLog.Common.AsyncLogEventInfo)">
            <summary>
            Writes async log event to the log target.
            </summary>
            <param name="logEvent">Async Log event to be written out.</param>
        </member>
        <member name="M:NLog.Targets.Target.WriteAsyncThreadSafe(NLog.Common.AsyncLogEventInfo)">
             <summary>
             Writes a log event to the log target, in a thread safe manner.
             Any override of this method has to provide their own synchronization mechanism.
            
             !WARNING! Custom targets should only override this method if able to provide their
             own synchronization mechanism. <see cref="T:NLog.Layouts.Layout" />-objects are not guaranteed to be
             thread-safe, so using them without a SyncRoot-object can be dangerous.
             </summary>
             <param name="logEvent">Log event to be written out.</param>
        </member>
        <member name="M:NLog.Targets.Target.Write(System.Collections.Generic.IList{NLog.Common.AsyncLogEventInfo})">
            <summary>
            Writes an array of logging events to the log target. By default it iterates on all
            events and passes them to "Write" method. Inheriting classes can use this method to
            optimize batch writes.
            </summary>
            <param name="logEvents">Logging events to be written out.</param>
        </member>
        <member name="M:NLog.Targets.Target.WriteAsyncThreadSafe(System.Collections.Generic.IList{NLog.Common.AsyncLogEventInfo})">
             <summary>
             Writes an array of logging events to the log target, in a thread safe manner.
             Any override of this method has to provide their own synchronization mechanism.
            
             !WARNING! Custom targets should only override this method if able to provide their
             own synchronization mechanism. <see cref="T:NLog.Layouts.Layout" />-objects are not guaranteed to be
             thread-safe, so using them without a SyncRoot-object can be dangerous.
             </summary>
             <param name="logEvents">Logging events to be written out.</param>
        </member>
        <member name="M:NLog.Targets.Target.MergeEventProperties(NLog.LogEventInfo)">
            <summary>
            Merges (copies) the event context properties from any event info object stored in
            parameters of the given event info object.
            </summary>
            <param name="logEvent">The event info object to perform the merge to.</param>
        </member>
        <member name="M:NLog.Targets.Target.RenderLogEvent(NLog.Layouts.Layout,NLog.LogEventInfo)">
            <summary>
            Renders the logevent into a string-result using the provided layout
            </summary>
            <param name="layout">The layout.</param>
            <param name="logEvent">The logevent info.</param>
            <returns>String representing log event.</returns>
        </member>
        <member name="M:NLog.Targets.Target.RenderLogEvent``1(NLog.Layouts.Layout{``0},NLog.LogEventInfo,``0)">
            <summary>
            Renders the logevent into a result-value by using the provided layout
            </summary>
            <typeparam name="T"></typeparam>
            <param name="layout">The layout.</param>
            <param name="logEvent">The logevent info.</param>
            <param name="defaultValue">Fallback value when no value available</param>
            <returns>Result value when available, else fallback to defaultValue</returns>
        </member>
        <member name="M:NLog.Targets.Target.ResolveService``1">
            <summary>
            Resolve from DI <see cref="P:NLog.LogFactory.ServiceRepository"/>
            </summary>
            <remarks>Avoid calling this while handling a LogEvent, since random deadlocks can occur.</remarks>
        </member>
        <member name="M:NLog.Targets.Target.ExceptionMustBeRethrown(System.Exception,System.String)">
             <summary>
             Should the exception be rethrown?
             </summary>
             <remarks>Upgrade to private protected when using C# 7.2 </remarks>
            
        </member>
        <member name="M:NLog.Targets.Target.Register``1(System.String)">
             <summary>
             Obsolete and replaced by <see cref="M:NLog.LogManager.Setup"/> with NLog v5.2.
            
             Register a custom Target.
             </summary>
             <remarks>Short-cut for registering to default <see cref="T:NLog.Config.ConfigurationItemFactory"/></remarks>
             <typeparam name="T">Type of the Target.</typeparam>
             <param name="name">The target type-alias for use in NLog configuration</param>
        </member>
        <member name="M:NLog.Targets.Target.Register(System.String,System.Type)">
             <summary>
             Obsolete and replaced by <see cref="M:NLog.LogManager.Setup"/> with NLog v5.2.
            
             Register a custom Target.
             </summary>
             <remarks>Short-cut for registering to default <see cref="T:NLog.Config.ConfigurationItemFactory"/></remarks>
             <param name="targetType">Type of the Target.</param>
             <param name="name">The target type-alias for use in NLog configuration</param>
        </member>
        <member name="T:NLog.Targets.TargetAttribute">
            <summary>
            Marks class as logging target and attaches a type-alias name for use in NLog configuration.
            </summary>
        </member>
        <member name="M:NLog.Targets.TargetAttribute.#ctor(System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.TargetAttribute" /> class.
            </summary>
            <param name="name">The target type-alias for use in NLog configuration.</param>
        </member>
        <member name="P:NLog.Targets.TargetAttribute.IsWrapper">
            <summary>
            Gets or sets a value indicating whether to the target is a wrapper target (used to generate the target summary documentation page).
            </summary>
        </member>
        <member name="P:NLog.Targets.TargetAttribute.IsCompound">
            <summary>
            Gets or sets a value indicating whether to the target is a compound target (used to generate the target summary documentation page).
            </summary>
        </member>
        <member name="T:NLog.Targets.TargetPropertyWithContext">
            <summary>
            Attribute details for <see cref="T:NLog.Targets.TargetWithContext"/>
            </summary>
        </member>
        <member name="M:NLog.Targets.TargetPropertyWithContext.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.TargetPropertyWithContext" /> class.
            </summary>
        </member>
        <member name="M:NLog.Targets.TargetPropertyWithContext.#ctor(System.String,NLog.Layouts.Layout)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.TargetPropertyWithContext" /> class.
            </summary>
            <param name="name">The name of the attribute.</param>
            <param name="layout">The layout of the attribute's value.</param>
        </member>
        <member name="P:NLog.Targets.TargetPropertyWithContext.Name">
            <summary>
            Gets or sets the name of the attribute.
            </summary>
            <docgen category='Layout Options' order='1' />
        </member>
        <member name="P:NLog.Targets.TargetPropertyWithContext.Layout">
            <summary>
            Gets or sets the layout that will be rendered as the attribute's value.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Targets.TargetPropertyWithContext.PropertyType">
            <summary>
            Gets or sets the type of the property.
            </summary>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="P:NLog.Targets.TargetPropertyWithContext.DefaultValue">
            <summary>
            Gets or sets the fallback value when result value is not available
            </summary>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="P:NLog.Targets.TargetPropertyWithContext.IncludeEmptyValue">
            <summary>
            Gets or sets when an empty value should cause the property to be included
            </summary>
            <docgen category='Layout Options' order='100' />
        </member>
        <member name="M:NLog.Targets.TargetPropertyWithContext.RenderValue(NLog.LogEventInfo)">
            <summary>
            Render Result Value
            </summary>
            <param name="logEvent">Log event for rendering</param>
            <returns>Result value when available, else fallback to defaultValue</returns>
        </member>
        <member name="T:NLog.Targets.TargetWithContext">
             <summary>
             Represents target that supports context capture of <see cref="T:NLog.ScopeContext"/> Properties + Nested-states
             </summary>
             <remarks>
             <a href="https://github.com/NLog/NLog/wiki/How-to-write-a-custom-target-for-structured-logging">See NLog Wiki</a>
             </remarks>
             <example><code>
             [Target("MyFirst")]
             public sealed class MyFirstTarget : TargetWithContext
             {
                public MyFirstTarget()
                {
                    this.Host = "localhost";
                }
            
                [RequiredParameter]
                public Layout Host { get; set; }
            
                protected override void Write(LogEventInfo logEvent)
                {
                    string logMessage = this.RenderLogEvent(this.Layout, logEvent);
                    string hostName = this.RenderLogEvent(this.Host, logEvent);
                    return SendTheMessageToRemoteHost(hostName, logMessage);
                }
            
                private void SendTheMessageToRemoteHost(string hostName, string message)
                {
                    // To be implemented
                }
             }
             </code></example>
             <seealso href="https://github.com/NLog/NLog/wiki/How-to-write-a-custom-target-for-structured-logging">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.Targets.TargetWithContext.Layout">
            <inheritdoc/>
            <docgen category='Layout Options' order='1' />
        </member>
        <member name="P:NLog.Targets.TargetWithContext.IncludeEventProperties">
            <summary>
            Gets or sets the option to include all properties from the log events
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Targets.TargetWithContext.IncludeScopeProperties">
            <summary>
            Gets or sets whether to include the contents of the <see cref="T:NLog.ScopeContext"/> properties-dictionary.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Targets.TargetWithContext.IncludeScopeNested">
            <summary>
            Gets or sets whether to include the contents of the <see cref="T:NLog.ScopeContext"/> nested-state-stack.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Targets.TargetWithContext.IncludeMdc">
            <summary>
            Obsolete and replaced by <see cref="P:NLog.Targets.TargetWithContext.IncludeScopeProperties"/> with NLog v5.
            Gets or sets whether to include the contents of the <see cref="T:NLog.MappedDiagnosticsContext"/>-dictionary.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Targets.TargetWithContext.IncludeNdc">
            <summary>
            Obsolete and replaced by <see cref="P:NLog.Targets.TargetWithContext.IncludeScopeNested"/> with NLog v5.
            Gets or sets whether to include the contents of the <see cref="T:NLog.NestedDiagnosticsContext"/>-stack.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Targets.TargetWithContext.IncludeMdlc">
            <summary>
            Obsolete and replaced by <see cref="P:NLog.Targets.TargetWithContext.IncludeScopeProperties"/> with NLog v5.
            Gets or sets whether to include the contents of the <see cref="T:NLog.MappedDiagnosticsLogicalContext"/>-properties.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Targets.TargetWithContext.IncludeNdlc">
            <summary>
            Obsolete and replaced by <see cref="P:NLog.Targets.TargetWithContext.IncludeScopeNested"/> with NLog v5.
            Gets or sets whether to include the contents of the <see cref="T:NLog.NestedDiagnosticsLogicalContext"/>-stack.
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Targets.TargetWithContext.IncludeGdc">
            <summary>
            Gets or sets a value indicating whether to include contents of the <see cref="T:NLog.GlobalDiagnosticsContext"/> dictionary
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Targets.TargetWithContext.IncludeCallSite">
            <summary>
            Gets or sets a value indicating whether to include call site (class and method name) in the <see cref="T:NLog.LogEventInfo" />
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Targets.TargetWithContext.IncludeCallSiteStackTrace">
            <summary>
            Gets or sets a value indicating whether to include source info (file name and line number) in the <see cref="T:NLog.LogEventInfo" />
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Targets.TargetWithContext.ContextProperties">
            <summary>
            Gets the array of custom attributes to be passed into the logevent context
            </summary>
            <docgen category='Layout Options' order='10' />
        </member>
        <member name="P:NLog.Targets.TargetWithContext.ExcludeProperties">
            <summary>
            List of property names to exclude when <see cref="P:NLog.Targets.TargetWithContext.IncludeEventProperties"/> is true
            </summary>
            <docgen category='Layout Options' order='50' />
        </member>
        <member name="M:NLog.Targets.TargetWithContext.#ctor">
            <summary>
            Constructor
            </summary>
        </member>
        <member name="M:NLog.Targets.TargetWithContext.ShouldIncludeProperties(NLog.LogEventInfo)">
            <summary>
            Check if logevent has properties (or context properties)
            </summary>
            <param name="logEvent"></param>
            <returns>True if properties should be included</returns>
        </member>
        <member name="M:NLog.Targets.TargetWithContext.GetContextProperties(NLog.LogEventInfo)">
            <summary>
            Checks if any context properties, and if any returns them as a single dictionary
            </summary>
            <param name="logEvent"></param>
            <returns>Dictionary with any context properties for the logEvent (Null if none found)</returns>
        </member>
        <member name="M:NLog.Targets.TargetWithContext.GetContextProperties(NLog.LogEventInfo,System.Collections.Generic.IDictionary{System.String,System.Object})">
            <summary>
            Checks if any context properties, and if any returns them as a single dictionary
            </summary>
            <param name="logEvent"></param>
            <param name="combinedProperties">Optional prefilled dictionary</param>
            <returns>Dictionary with any context properties for the logEvent (Null if none found)</returns>
        </member>
        <member name="M:NLog.Targets.TargetWithContext.GetAllProperties(NLog.LogEventInfo)">
            <summary>
            Creates combined dictionary of all configured properties for logEvent
            </summary>
            <param name="logEvent"></param>
            <returns>Dictionary with all collected properties for logEvent</returns>
        </member>
        <member name="M:NLog.Targets.TargetWithContext.GetAllProperties(NLog.LogEventInfo,System.Collections.Generic.IDictionary{System.String,System.Object})">
            <summary>
            Creates combined dictionary of all configured properties for logEvent
            </summary>
            <param name="logEvent"></param>
            <param name="combinedProperties">Optional prefilled dictionary</param>
            <returns>Dictionary with all collected properties for logEvent</returns>
        </member>
        <member name="M:NLog.Targets.TargetWithContext.GenerateUniqueItemName(NLog.LogEventInfo,System.String,System.Object,System.Collections.Generic.IDictionary{System.String,System.Object})">
            <summary>
            Generates a new unique name, when duplicate names are detected
            </summary>
            <param name="logEvent">LogEvent that triggered the duplicate name</param>
            <param name="itemName">Duplicate item name</param>
            <param name="itemValue">Item Value</param>
            <param name="combinedProperties">Dictionary of context values</param>
            <returns>New (unique) value (or null to skip value). If the same value is used then the item will be overwritten</returns>
        </member>
        <member name="M:NLog.Targets.TargetWithContext.GetContextMdc(NLog.LogEventInfo)">
            <summary>
            Obsolete and replaced by <see cref="M:NLog.Targets.TargetWithContext.GetScopeContextProperties(NLog.LogEventInfo)"/> with NLog v5.
            Returns the captured snapshot of <see cref="T:NLog.MappedDiagnosticsContext"/> for the <see cref="T:NLog.LogEventInfo"/>
            </summary>
            <param name="logEvent"></param>
            <returns>Dictionary with MDC context if any, else null</returns>
        </member>
        <member name="M:NLog.Targets.TargetWithContext.GetScopeContextProperties(NLog.LogEventInfo)">
            <summary>
            Returns the captured snapshot of <see cref="T:NLog.ScopeContext"/> dictionary for the <see cref="T:NLog.LogEventInfo"/>
            </summary>
            <param name="logEvent"></param>
            <returns>Dictionary with ScopeContext properties if any, else null</returns>
        </member>
        <member name="M:NLog.Targets.TargetWithContext.GetContextMdlc(NLog.LogEventInfo)">
            <summary>
            Obsolete and replaced by <see cref="M:NLog.Targets.TargetWithContext.GetScopeContextProperties(NLog.LogEventInfo)"/> with NLog v5.
            Returns the captured snapshot of <see cref="T:NLog.MappedDiagnosticsLogicalContext"/> for the <see cref="T:NLog.LogEventInfo"/>
            </summary>
            <param name="logEvent"></param>
            <returns>Dictionary with MDLC context if any, else null</returns>
        </member>
        <member name="M:NLog.Targets.TargetWithContext.GetContextNdc(NLog.LogEventInfo)">
            <summary>
            Obsolete and replaced by <see cref="M:NLog.Targets.TargetWithContext.GetScopeContextNested(NLog.LogEventInfo)"/> with NLog v5.
            Returns the captured snapshot of <see cref="T:NLog.NestedDiagnosticsContext"/> for the <see cref="T:NLog.LogEventInfo"/>
            </summary>
            <param name="logEvent"></param>
            <returns>Collection with NDC context if any, else null</returns>
        </member>
        <member name="M:NLog.Targets.TargetWithContext.GetScopeContextNested(NLog.LogEventInfo)">
            <summary>
            Returns the captured snapshot of nested states from <see cref="T:NLog.ScopeContext"/> for the <see cref="T:NLog.LogEventInfo"/>
            </summary>
            <param name="logEvent"></param>
            <returns>Collection of nested state objects if any, else null</returns>
        </member>
        <member name="M:NLog.Targets.TargetWithContext.GetContextNdlc(NLog.LogEventInfo)">
            <summary>
            Obsolete and replaced by <see cref="M:NLog.Targets.TargetWithContext.GetScopeContextNested(NLog.LogEventInfo)"/> with NLog v5.
            Returns the captured snapshot of <see cref="T:NLog.NestedDiagnosticsLogicalContext"/> for the <see cref="T:NLog.LogEventInfo"/>
            </summary>
            <param name="logEvent"></param>
            <returns>Collection with NDLC context if any, else null</returns>
        </member>
        <member name="M:NLog.Targets.TargetWithContext.CaptureContextGdc(NLog.LogEventInfo,System.Collections.Generic.IDictionary{System.String,System.Object})">
            <summary>
            Takes snapshot of <see cref="T:NLog.GlobalDiagnosticsContext"/> for the <see cref="T:NLog.LogEventInfo"/>
            </summary>
            <param name="logEvent"></param>
            <param name="contextProperties">Optional pre-allocated dictionary for the snapshot</param>
            <returns>Dictionary with GDC context if any, else null</returns>
        </member>
        <member name="M:NLog.Targets.TargetWithContext.CaptureContextMdc(NLog.LogEventInfo,System.Collections.Generic.IDictionary{System.String,System.Object})">
            <summary>
            Obsolete and replaced by <see cref="M:NLog.Targets.TargetWithContext.CaptureScopeContextProperties(NLog.LogEventInfo,System.Collections.Generic.IDictionary{System.String,System.Object})"/> with NLog v5.
            Takes snapshot of <see cref="T:NLog.MappedDiagnosticsContext"/> for the <see cref="T:NLog.LogEventInfo"/>
            </summary>
            <param name="logEvent"></param>
            <param name="contextProperties">Optional pre-allocated dictionary for the snapshot</param>
            <returns>Dictionary with MDC context if any, else null</returns>
        </member>
        <member name="M:NLog.Targets.TargetWithContext.SerializeMdcItem(NLog.LogEventInfo,System.String,System.Object,System.Object@)">
            <summary>
            Obsolete and replaced by <see cref="M:NLog.Targets.TargetWithContext.SerializeScopeContextProperty(NLog.LogEventInfo,System.String,System.Object,System.Object@)"/> with NLog v5.
            Take snapshot of a single object value from <see cref="T:NLog.MappedDiagnosticsContext"/>
            </summary>
            <param name="logEvent">Log event</param>
            <param name="name">MDC key</param>
            <param name="value">MDC value</param>
            <param name="serializedValue">Snapshot of MDC value</param>
            <returns>Include object value in snapshot</returns>
        </member>
        <member name="M:NLog.Targets.TargetWithContext.CaptureContextMdlc(NLog.LogEventInfo,System.Collections.Generic.IDictionary{System.String,System.Object})">
            <summary>
            Obsolete and replaced by <see cref="M:NLog.Targets.TargetWithContext.CaptureScopeContextProperties(NLog.LogEventInfo,System.Collections.Generic.IDictionary{System.String,System.Object})"/> with NLog v5.
            Takes snapshot of <see cref="T:NLog.MappedDiagnosticsLogicalContext"/> for the <see cref="T:NLog.LogEventInfo"/>
            </summary>
            <param name="logEvent"></param>
            <param name="contextProperties">Optional pre-allocated dictionary for the snapshot</param>
            <returns>Dictionary with MDLC context if any, else null</returns>
        </member>
        <member name="M:NLog.Targets.TargetWithContext.CaptureScopeContextProperties(NLog.LogEventInfo,System.Collections.Generic.IDictionary{System.String,System.Object})">
            <summary>
            Takes snapshot of <see cref="T:NLog.ScopeContext"/> dictionary for the <see cref="T:NLog.LogEventInfo"/>
            </summary>
            <param name="logEvent"></param>
            <param name="contextProperties">Optional pre-allocated dictionary for the snapshot</param>
            <returns>Dictionary with ScopeContext properties if any, else null</returns>
        </member>
        <member name="M:NLog.Targets.TargetWithContext.SerializeMdlcItem(NLog.LogEventInfo,System.String,System.Object,System.Object@)">
            <summary>
            Obsolete and replaced by <see cref="M:NLog.Targets.TargetWithContext.SerializeScopeContextProperty(NLog.LogEventInfo,System.String,System.Object,System.Object@)"/> with NLog v5.
            Take snapshot of a single object value from <see cref="T:NLog.MappedDiagnosticsLogicalContext"/>
            </summary>
            <param name="logEvent">Log event</param>
            <param name="name">MDLC key</param>
            <param name="value">MDLC value</param>
            <param name="serializedValue">Snapshot of MDLC value</param>
            <returns>Include object value in snapshot</returns>
        </member>
        <member name="M:NLog.Targets.TargetWithContext.SerializeScopeContextProperty(NLog.LogEventInfo,System.String,System.Object,System.Object@)">
            <summary>
            Take snapshot of a single object value from <see cref="T:NLog.ScopeContext"/> dictionary
            </summary>
            <param name="logEvent">Log event</param>
            <param name="name">ScopeContext Dictionary key</param>
            <param name="value">ScopeContext Dictionary value</param>
            <param name="serializedValue">Snapshot of ScopeContext property-value</param>
            <returns>Include object value in snapshot</returns>
        </member>
        <member name="M:NLog.Targets.TargetWithContext.CaptureContextNdc(NLog.LogEventInfo)">
            <summary>
            Obsolete and replaced by <see cref="M:NLog.Targets.TargetWithContext.CaptureScopeContextNested(NLog.LogEventInfo)"/> with NLog v5.
            Takes snapshot of <see cref="T:NLog.NestedDiagnosticsContext"/> for the <see cref="T:NLog.LogEventInfo"/>
            </summary>
            <param name="logEvent"></param>
            <returns>Collection with NDC context if any, else null</returns>
        </member>
        <member name="M:NLog.Targets.TargetWithContext.SerializeNdcItem(NLog.LogEventInfo,System.Object,System.Object@)">
            <summary>
            Obsolete and replaced by <see cref="M:NLog.Targets.TargetWithContext.SerializeScopeContextNestedState(NLog.LogEventInfo,System.Object,System.Object@)"/> with NLog v5.
            Take snapshot of a single object value from <see cref="T:NLog.NestedDiagnosticsContext"/>
            </summary>
            <param name="logEvent">Log event</param>
            <param name="value">NDC value</param>
            <param name="serializedValue">Snapshot of NDC value</param>
            <returns>Include object value in snapshot</returns>
        </member>
        <member name="M:NLog.Targets.TargetWithContext.CaptureContextNdlc(NLog.LogEventInfo)">
            <summary>
            Obsolete and replaced by <see cref="M:NLog.Targets.TargetWithContext.CaptureScopeContextNested(NLog.LogEventInfo)"/> with NLog v5.
            Takes snapshot of <see cref="T:NLog.NestedDiagnosticsLogicalContext"/> for the <see cref="T:NLog.LogEventInfo"/>
            </summary>
            <param name="logEvent"></param>
            <returns>Collection with NDLC context if any, else null</returns>
        </member>
        <member name="M:NLog.Targets.TargetWithContext.CaptureScopeContextNested(NLog.LogEventInfo)">
            <summary>
            Takes snapshot of nested states from <see cref="T:NLog.ScopeContext"/> for the <see cref="T:NLog.LogEventInfo"/>
            </summary>
            <param name="logEvent"></param>
            <returns>Collection with <see cref="T:NLog.ScopeContext"/> stack items if any, else null</returns>
        </member>
        <member name="M:NLog.Targets.TargetWithContext.SerializeNdlcItem(NLog.LogEventInfo,System.Object,System.Object@)">
            <summary>
            Obsolete and replaced by <see cref="M:NLog.Targets.TargetWithContext.SerializeScopeContextNestedState(NLog.LogEventInfo,System.Object,System.Object@)"/> with NLog v5.
            Take snapshot of a single object value from <see cref="T:NLog.NestedDiagnosticsLogicalContext"/>
            </summary>
            <param name="logEvent">Log event</param>
            <param name="value">NDLC value</param>
            <param name="serializedValue">Snapshot of NDLC value</param>
            <returns>Include object value in snapshot</returns>
        </member>
        <member name="M:NLog.Targets.TargetWithContext.SerializeScopeContextNestedState(NLog.LogEventInfo,System.Object,System.Object@)">
            <summary>
            Take snapshot of a single object value from <see cref="T:NLog.ScopeContext"/> nested states
            </summary>
            <param name="logEvent">Log event</param>
            <param name="value"><see cref="T:NLog.ScopeContext"/> nested state value</param>
            <param name="serializedValue">Snapshot of <see cref="T:NLog.ScopeContext"/> stack item value</param>
            <returns>Include object value in snapshot</returns>
        </member>
        <member name="M:NLog.Targets.TargetWithContext.SerializeItemValue(NLog.LogEventInfo,System.String,System.Object,System.Object@)">
            <summary>
            Take snapshot of a single object value
            </summary>
            <param name="logEvent">Log event</param>
            <param name="name">Key Name (null when NDC / NDLC)</param>
            <param name="value">Object Value</param>
            <param name="serializedValue">Snapshot of value</param>
            <returns>Include object value in snapshot</returns>
        </member>
        <member name="P:NLog.Targets.TargetWithContext.TargetWithContextLayout.ScopeContextPropertiesLayout">
            <summary>Internal Layout that allows capture of <see cref="T:NLog.ScopeContext"/> properties-dictionary</summary>
        </member>
        <member name="P:NLog.Targets.TargetWithContext.TargetWithContextLayout.ScopeContextNestedStatesLayout">
            <summary>Internal Layout that allows capture of <see cref="T:NLog.ScopeContext"/> nested-states-stack</summary>
        </member>
        <member name="T:NLog.Targets.TargetWithLayout">
            <summary>
            Represents target that supports string formatting using layouts.
            </summary>
            <remarks>
            <a href="https://github.com/NLog/NLog/wiki/How-to-write-a-custom-target">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/How-to-write-a-custom-target">Documentation on NLog Wiki</seealso>
        </member>
        <member name="M:NLog.Targets.TargetWithLayout.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.TargetWithLayout" /> class.
            </summary>
            <remarks>
            The default value of the layout is: <code>${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}</code>
            </remarks>
        </member>
        <member name="P:NLog.Targets.TargetWithLayout.Layout">
            <summary>
            Gets or sets the layout used to format log messages.
            </summary>
            <remarks>
            The default value of the layout is: <code>${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}</code>
            </remarks>
            <docgen category='Layout Options' order='1' />
        </member>
        <member name="T:NLog.Targets.TargetWithLayoutHeaderAndFooter">
            <summary>
            Represents target that supports string formatting using layouts.
            </summary>
        </member>
        <member name="M:NLog.Targets.TargetWithLayoutHeaderAndFooter.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.TargetWithLayoutHeaderAndFooter" /> class.
            </summary>
            <remarks>
            The default value of the layout is: <code>${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}</code>
            </remarks>
        </member>
        <member name="P:NLog.Targets.TargetWithLayoutHeaderAndFooter.Layout">
            <summary>
            Gets or sets the text to be rendered.
            </summary>
            <remarks>
            The default value of the layout is: <code>${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}</code>
            </remarks>
            <docgen category='Layout Options' order='1' />
        </member>
        <member name="P:NLog.Targets.TargetWithLayoutHeaderAndFooter.Footer">
            <summary>
            Gets or sets the footer.
            </summary>
            <docgen category='Layout Options' order='3' />
        </member>
        <member name="P:NLog.Targets.TargetWithLayoutHeaderAndFooter.Header">
            <summary>
            Gets or sets the header.
            </summary>
            <docgen category='Layout Options' order='2' />
        </member>
        <member name="P:NLog.Targets.TargetWithLayoutHeaderAndFooter.LHF">
            <summary>
            Gets or sets the layout with header and footer.
            </summary>
            <value>The layout with header and footer.</value>
        </member>
        <member name="T:NLog.Targets.TraceTarget">
            <summary>
            Sends log messages through System.Diagnostics.Trace.
            </summary>
            <remarks>
            <a href="https://github.com/nlog/nlog/wiki/Trace-target">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/nlog/nlog/wiki/Trace-target">Documentation on NLog Wiki</seealso>
            <example>
            <p>
            To set up the target in the <a href="https://github.com/NLog/NLog/wiki/Configuration-file">configuration file</a>,
            use the following syntax:
            </p>
            <code lang="XML" source="examples/targets/Configuration File/Trace/NLog.config" />
            <p>
            To set up the log target programmatically use code like this:
            </p>
            <code lang="C#" source="examples/targets/Configuration API/Trace/Simple/Example.cs" />
            </example>
        </member>
        <member name="P:NLog.Targets.TraceTarget.RawWrite">
            <summary>
            Force use <see cref="M:System.Diagnostics.Trace.WriteLine(System.String)"/> independent of <see cref="T:NLog.LogLevel"/>
            </summary>
            <docgen category='Output Options' order='100' />
        </member>
        <member name="P:NLog.Targets.TraceTarget.EnableTraceFail">
            <summary>
            Forward <see cref="F:NLog.LogLevel.Fatal" /> to <see cref="M:System.Diagnostics.Trace.Fail(System.String)" /> (Instead of <see cref="M:System.Diagnostics.Trace.TraceError(System.String)" />)
            </summary>
            <remarks>
            Trace.Fail can have special side-effects, and give fatal exceptions, message dialogs or Environment.FailFast
            </remarks>
            <docgen category='Output Options' order='100' />
        </member>
        <member name="M:NLog.Targets.TraceTarget.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.TraceTarget" /> class.
            </summary>
            <remarks>
            The default value of the layout is: <code>${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}</code>
            </remarks>
        </member>
        <member name="M:NLog.Targets.TraceTarget.#ctor(System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.TraceTarget" /> class.
            </summary>
            <remarks>
            The default value of the layout is: <code>${longdate}|${level:uppercase=true}|${logger}|${message:withexception=true}</code>
            </remarks>
            <param name="name">Name of the target.</param>
        </member>
        <member name="M:NLog.Targets.TraceTarget.InitializeTarget">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Targets.TraceTarget.CloseTarget">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Targets.TraceTarget.Write(NLog.LogEventInfo)">
             <summary>
             Writes the specified logging event to the <see cref="T:System.Diagnostics.Trace"/> facility.
            
             Redirects the log message depending on <see cref="T:NLog.LogLevel"/> and  <see cref="P:NLog.Targets.TraceTarget.RawWrite"/>.
             When <see cref="P:NLog.Targets.TraceTarget.RawWrite"/> is <c>false</c>:
              - <see cref="F:NLog.LogLevel.Fatal"/> writes to <see cref="M:System.Diagnostics.Trace.TraceError(System.String)" />
              - <see cref="F:NLog.LogLevel.Error"/> writes to <see cref="M:System.Diagnostics.Trace.TraceError(System.String)" />
              - <see cref="F:NLog.LogLevel.Warn"/> writes to <see cref="M:System.Diagnostics.Trace.TraceWarning(System.String)" />
              - <see cref="F:NLog.LogLevel.Info"/> writes to <see cref="M:System.Diagnostics.Trace.TraceInformation(System.String)" />
              - <see cref="F:NLog.LogLevel.Debug"/> writes to <see cref="M:System.Diagnostics.Trace.WriteLine(System.String)" />
              - <see cref="F:NLog.LogLevel.Trace"/> writes to <see cref="M:System.Diagnostics.Trace.WriteLine(System.String)" />
             </summary>
             <param name="logEvent">The logging event.</param>
        </member>
        <member name="T:NLog.Targets.WebServiceProtocol">
            <summary>
            Web service protocol.
            </summary>
        </member>
        <member name="F:NLog.Targets.WebServiceProtocol.Soap11">
            <summary>
            Use SOAP 1.1 Protocol.
            </summary>
        </member>
        <member name="F:NLog.Targets.WebServiceProtocol.Soap12">
            <summary>
            Use SOAP 1.2 Protocol.
            </summary>
        </member>
        <member name="F:NLog.Targets.WebServiceProtocol.HttpPost">
            <summary>
            Use HTTP POST Protocol.
            </summary>
        </member>
        <member name="F:NLog.Targets.WebServiceProtocol.HttpGet">
            <summary>
            Use HTTP GET Protocol.
            </summary>
        </member>
        <member name="F:NLog.Targets.WebServiceProtocol.JsonPost">
            <summary>
            Do an HTTP POST of a JSON document.
            </summary>
        </member>
        <member name="F:NLog.Targets.WebServiceProtocol.XmlPost">
            <summary>
            Do an HTTP POST of an XML document.
            </summary>
        </member>
        <member name="T:NLog.Targets.WebServiceProxyType">
            <summary>
            Web Service Proxy Configuration Type
            </summary>
        </member>
        <member name="F:NLog.Targets.WebServiceProxyType.DefaultWebProxy">
            <summary>
            Default proxy configuration from app.config (System.Net.WebRequest.DefaultWebProxy)
            </summary>
            <example>
            Example of how to configure default proxy using app.config
            <code>
            &lt;system.net&gt;
               &lt;defaultProxy enabled = "true" useDefaultCredentials = "true" &gt;
                  &lt;proxy usesystemdefault = "True" /&gt;
               &lt;/defaultProxy&gt;
            &lt;/system.net&gt;
            </code>
            </example>
        </member>
        <member name="F:NLog.Targets.WebServiceProxyType.AutoProxy">
            <summary>
            Automatic use of proxy with authentication (cached)
            </summary>
        </member>
        <member name="F:NLog.Targets.WebServiceProxyType.NoProxy">
            <summary>
            Disables use of proxy (fast)
            </summary>
        </member>
        <member name="F:NLog.Targets.WebServiceProxyType.ProxyAddress">
            <summary>
            Custom proxy address (cached)
            </summary>
        </member>
        <member name="T:NLog.Targets.WebServiceTarget">
            <summary>
            Calls the specified web service on each log message.
            </summary>
            <remarks>
            <a href="https://github.com/nlog/nlog/wiki/WebService-target">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/nlog/nlog/wiki/WebService-target">Documentation on NLog Wiki</seealso>
            <remarks>
            The web service must implement a method that accepts a number of string parameters.
            </remarks>
            <example>
            <p>
            To set up the target in the <a href="https://github.com/NLog/NLog/wiki/Configuration-file">configuration file</a>,
            use the following syntax:
            </p>
            <code lang="XML" source="examples/targets/Configuration File/WebService/NLog.config" />
            <p>
            To set up the log target programmatically use code like this:
            </p>
            <code lang="C#" source="examples/targets/Configuration API/WebService/Simple/Example.cs" />
            <p>The example web service that works with this example is shown below</p>
            <code lang="C#" source="examples/targets/Configuration API/WebService/Simple/WebService1/Service1.asmx.cs" />
            </example>
        </member>
        <member name="F:NLog.Targets.WebServiceTarget._postFormatterFactories">
            <summary>
            dictionary that maps a concrete <see cref="T:NLog.Targets.WebServiceTarget.HttpPostFormatterBase"/> implementation
            to a specific <see cref="T:NLog.Targets.WebServiceProtocol"/>-value.
            </summary>
        </member>
        <member name="M:NLog.Targets.WebServiceTarget.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.WebServiceTarget" /> class.
            </summary>
        </member>
        <member name="M:NLog.Targets.WebServiceTarget.#ctor(System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.WebServiceTarget" /> class.
            </summary>
            <param name="name">Name of the target</param>
        </member>
        <member name="P:NLog.Targets.WebServiceTarget.Url">
            <summary>
            Gets or sets the web service URL.
            </summary>
            <docgen category='Web Service Options' order='10' />
        </member>
        <member name="P:NLog.Targets.WebServiceTarget.UserAgent">
            <summary>
            Gets or sets the value of the User-agent HTTP header.
            </summary>
            <docgen category='Web Service Options' order='10' />
        </member>
        <member name="P:NLog.Targets.WebServiceTarget.MethodName">
            <summary>
            Gets or sets the Web service method name. Only used with Soap.
            </summary>
            <docgen category='Web Service Options' order='10' />
        </member>
        <member name="P:NLog.Targets.WebServiceTarget.Namespace">
            <summary>
            Gets or sets the Web service namespace. Only used with Soap.
            </summary>
            <docgen category='Web Service Options' order='10' />
        </member>
        <member name="P:NLog.Targets.WebServiceTarget.Protocol">
            <summary>
            Gets or sets the protocol to be used when calling web service.
            </summary>
            <docgen category='Web Service Options' order='10' />
        </member>
        <member name="P:NLog.Targets.WebServiceTarget.ProxyType">
            <summary>
            Gets or sets the proxy configuration when calling web service
            </summary>
            <remarks>
            Changing ProxyType on Net5 (or newer) will turn off Http-connection-pooling
            </remarks>
            <docgen category='Web Service Options' order='10' />
        </member>
        <member name="P:NLog.Targets.WebServiceTarget.ProxyAddress">
            <summary>
            Gets or sets the custom proxy address, include port separated by a colon
            </summary>
            <docgen category='Web Service Options' order='10' />
        </member>
        <member name="P:NLog.Targets.WebServiceTarget.IncludeBOM">
             <summary>
             Should we include the BOM (Byte-order-mark) for UTF? Influences the <see cref="P:NLog.Targets.WebServiceTarget.Encoding"/> property.
            
             This will only work for UTF-8.
             </summary>
             <docgen category='Web Service Options' order='10' />
        </member>
        <member name="P:NLog.Targets.WebServiceTarget.Encoding">
            <summary>
            Gets or sets the encoding.
            </summary>
            <docgen category='Web Service Options' order='10' />
        </member>
        <member name="P:NLog.Targets.WebServiceTarget.EscapeDataRfc3986">
            <summary>
            Gets or sets a value whether escaping be done according to Rfc3986 (Supports Internationalized Resource Identifiers - IRIs)
            </summary>
            <value>A value of <c>true</c> if Rfc3986; otherwise, <c>false</c> for legacy Rfc2396.</value>
            <docgen category='Web Service Options' order='100' />
        </member>
        <member name="P:NLog.Targets.WebServiceTarget.EscapeDataNLogLegacy">
            <summary>
            Gets or sets a value whether escaping be done according to the old NLog style (Very non-standard)
            </summary>
            <value>A value of <c>true</c> if legacy encoding; otherwise, <c>false</c> for standard UTF8 encoding.</value>
            <docgen category='Web Service Options' order='100' />
        </member>
        <member name="P:NLog.Targets.WebServiceTarget.XmlRoot">
            <summary>
            Gets or sets the name of the root XML element,
            if POST of XML document chosen.
            If so, this property must not be <c>null</c>.
            (see <see cref="P:NLog.Targets.WebServiceTarget.Protocol"/> and <see cref="F:NLog.Targets.WebServiceProtocol.XmlPost"/>).
            </summary>
            <docgen category='Web Service Options' order='100' />
        </member>
        <member name="P:NLog.Targets.WebServiceTarget.XmlRootNamespace">
            <summary>
            Gets or sets the (optional) root namespace of the XML document,
            if POST of XML document chosen.
            (see <see cref="P:NLog.Targets.WebServiceTarget.Protocol"/> and <see cref="F:NLog.Targets.WebServiceProtocol.XmlPost"/>).
            </summary>
            <docgen category='Web Service Options' order='100' />
        </member>
        <member name="P:NLog.Targets.WebServiceTarget.Headers">
            <summary>
            Gets the array of parameters to be passed.
            </summary>
            <docgen category='Web Service Options' order='10' />
        </member>
        <member name="P:NLog.Targets.WebServiceTarget.PreAuthenticate">
            <summary>
            Indicates whether to pre-authenticate the HttpWebRequest (Requires 'Authorization' in <see cref="P:NLog.Targets.WebServiceTarget.Headers"/> parameters)
            </summary>
            <docgen category='Web Service Options' order='100' />
        </member>
        <member name="M:NLog.Targets.WebServiceTarget.DoInvoke(System.Object[])">
            <summary>
            Calls the target method. Must be implemented in concrete classes.
            </summary>
            <param name="parameters">Method call parameters.</param>
        </member>
        <member name="M:NLog.Targets.WebServiceTarget.DoInvoke(System.Object[],NLog.Common.AsyncContinuation)">
            <summary>
            Calls the target DoInvoke method, and handles AsyncContinuation callback
            </summary>
            <param name="parameters">Method call parameters.</param>
            <param name="continuation">The continuation.</param>
        </member>
        <member name="M:NLog.Targets.WebServiceTarget.DoInvoke(System.Object[],NLog.Common.AsyncLogEventInfo)">
            <summary>
            Invokes the web service method.
            </summary>
            <param name="parameters">Parameters to be passed.</param>
            <param name="logEvent">The logging event.</param>
        </member>
        <member name="M:NLog.Targets.WebServiceTarget.FlushAsync(NLog.Common.AsyncContinuation)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Targets.WebServiceTarget.CloseTarget">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Targets.WebServiceTarget.BuildWebServiceUrl(NLog.LogEventInfo,System.Object[])">
            <summary>
            Builds the URL to use when calling the web service for a message, depending on the WebServiceProtocol.
            </summary>
        </member>
        <member name="M:NLog.Targets.WebServiceTarget.WriteStreamAndFixPreamble(System.IO.MemoryStream,System.IO.Stream,System.Nullable{System.Boolean},System.Text.Encoding)">
            <summary>
            Write from input to output. Fix the UTF-8 bom
            </summary>
        </member>
        <member name="T:NLog.Targets.WebServiceTarget.HttpPostFormatterBase">
            <summary>
            base class for POST formatters, that
            implement former <c>PrepareRequest()</c> method,
            that creates the content for
            the requested kind of HTTP request
            </summary>
        </member>
        <member name="T:NLog.Targets.Win32FileAttributes">
            <summary>
            Win32 file attributes.
            </summary>
            <remarks>
            For more information see <a href="https://msdn.microsoft.com/library/default.asp?url=/library/en-us/fileio/fs/createfile.asp">https://msdn.microsoft.com/library/default.asp?url=/library/en-us/fileio/fs/createfile.asp</a>.
            </remarks>
        </member>
        <member name="F:NLog.Targets.Win32FileAttributes.ReadOnly">
            <summary>
            Read-only file.
            </summary>
        </member>
        <member name="F:NLog.Targets.Win32FileAttributes.Hidden">
            <summary>
            Hidden file.
            </summary>
        </member>
        <member name="F:NLog.Targets.Win32FileAttributes.System">
            <summary>
            System file.
            </summary>
        </member>
        <member name="F:NLog.Targets.Win32FileAttributes.Archive">
            <summary>
            File should be archived.
            </summary>
        </member>
        <member name="F:NLog.Targets.Win32FileAttributes.Device">
            <summary>
            Device file.
            </summary>
        </member>
        <member name="F:NLog.Targets.Win32FileAttributes.Normal">
            <summary>
            Normal file.
            </summary>
        </member>
        <member name="F:NLog.Targets.Win32FileAttributes.Temporary">
            <summary>
            File is temporary (should be kept in cache and not
            written to disk if possible).
            </summary>
        </member>
        <member name="F:NLog.Targets.Win32FileAttributes.SparseFile">
            <summary>
            Sparse file.
            </summary>
        </member>
        <member name="F:NLog.Targets.Win32FileAttributes.ReparsePoint">
            <summary>
            Reparse point.
            </summary>
        </member>
        <member name="F:NLog.Targets.Win32FileAttributes.Compressed">
            <summary>
            Compress file contents.
            </summary>
        </member>
        <member name="F:NLog.Targets.Win32FileAttributes.NotContentIndexed">
            <summary>
            File should not be indexed by the content indexing service.
            </summary>
        </member>
        <member name="F:NLog.Targets.Win32FileAttributes.Encrypted">
            <summary>
            Encrypted file.
            </summary>
        </member>
        <member name="F:NLog.Targets.Win32FileAttributes.WriteThrough">
            <summary>
            The system writes through any intermediate cache and goes directly to disk.
            </summary>
        </member>
        <member name="F:NLog.Targets.Win32FileAttributes.NoBuffering">
            <summary>
            The system opens a file with no system caching.
            </summary>
        </member>
        <member name="F:NLog.Targets.Win32FileAttributes.DeleteOnClose">
            <summary>
            Delete file after it is closed.
            </summary>
        </member>
        <member name="F:NLog.Targets.Win32FileAttributes.PosixSemantics">
            <summary>
            A file is accessed according to POSIX rules.
            </summary>
        </member>
        <member name="T:NLog.Targets.Wrappers.AsyncRequestQueue">
            <summary>
            Asynchronous request queue.
            </summary>
        </member>
        <member name="M:NLog.Targets.Wrappers.AsyncRequestQueue.#ctor(System.Int32,NLog.Targets.Wrappers.AsyncTargetWrapperOverflowAction)">
            <summary>
            Initializes a new instance of the AsyncRequestQueue class.
            </summary>
            <param name="requestLimit">Request limit.</param>
            <param name="overflowAction">The overflow action.</param>
        </member>
        <member name="P:NLog.Targets.Wrappers.AsyncRequestQueue.RequestCount">
            <summary>
            Gets the number of requests currently in the queue.
            </summary>
        </member>
        <member name="M:NLog.Targets.Wrappers.AsyncRequestQueue.Enqueue(NLog.Common.AsyncLogEventInfo)">
            <summary>
            Enqueues another item. If the queue is overflown the appropriate
            action is taken as specified by <see cref="P:NLog.Targets.Wrappers.AsyncRequestQueueBase.OnOverflow"/>.
            </summary>
            <param name="logEventInfo">The log event info.</param>
            <returns>Queue was empty before enqueue</returns>
        </member>
        <member name="M:NLog.Targets.Wrappers.AsyncRequestQueue.DequeueBatch(System.Int32)">
            <summary>
            Dequeues a maximum of <c>count</c> items from the queue
            and adds returns the list containing them.
            </summary>
            <param name="count">Maximum number of items to be dequeued</param>
            <returns>The array of log events.</returns>
        </member>
        <member name="M:NLog.Targets.Wrappers.AsyncRequestQueue.DequeueBatch(System.Int32,System.Collections.Generic.IList{NLog.Common.AsyncLogEventInfo})">
            <summary>
            Dequeues into a preallocated array, instead of allocating a new one
            </summary>
            <param name="count">Maximum number of items to be dequeued</param>
            <param name="result">Preallocated list</param>
        </member>
        <member name="M:NLog.Targets.Wrappers.AsyncRequestQueue.Clear">
            <summary>
            Clears the queue.
            </summary>
        </member>
        <member name="P:NLog.Targets.Wrappers.AsyncRequestQueueBase.RequestLimit">
            <summary>
            Gets or sets the request limit.
            </summary>
        </member>
        <member name="P:NLog.Targets.Wrappers.AsyncRequestQueueBase.OnOverflow">
            <summary>
            Gets or sets the action to be taken when there's no more room in
            the queue and another request is enqueued.
            </summary>
        </member>
        <member name="E:NLog.Targets.Wrappers.AsyncRequestQueueBase.LogEventDropped">
            <summary>
            Occurs when LogEvent has been dropped, because internal queue is full and <see cref="P:NLog.Targets.Wrappers.AsyncRequestQueueBase.OnOverflow"/> set to <see cref="F:NLog.Targets.Wrappers.AsyncTargetWrapperOverflowAction.Discard"/>
            </summary>
        </member>
        <member name="E:NLog.Targets.Wrappers.AsyncRequestQueueBase.LogEventQueueGrow">
            <summary>
            Occurs when internal queue size is growing, because internal queue is full and <see cref="P:NLog.Targets.Wrappers.AsyncRequestQueueBase.OnOverflow"/> set to <see cref="F:NLog.Targets.Wrappers.AsyncTargetWrapperOverflowAction.Grow"/>
            </summary>
        </member>
        <member name="M:NLog.Targets.Wrappers.AsyncRequestQueueBase.OnLogEventDropped(NLog.LogEventInfo)">
            <summary>
            Raise event when queued element was dropped because of queue overflow
            </summary>
            <param name="logEventInfo">Dropped queue item</param>
        </member>
        <member name="M:NLog.Targets.Wrappers.AsyncRequestQueueBase.OnLogEventQueueGrows(System.Int64)">
            <summary>
            Raise event when RequestCount overflow <see cref="P:NLog.Targets.Wrappers.AsyncRequestQueueBase.RequestLimit"/>
            </summary>
            <param name="requestsCount"> current requests count</param>
        </member>
        <member name="T:NLog.Targets.Wrappers.AsyncTargetWrapper">
            <summary>
            Provides asynchronous, buffered execution of target writes.
            </summary>
            <remarks>
            <a href="https://github.com/nlog/nlog/wiki/AsyncWrapper-target">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/nlog/nlog/wiki/AsyncWrapper-target">Documentation on NLog Wiki</seealso>
            <remarks>
            <p>
            Asynchronous target wrapper allows the logger code to execute more quickly, by queuing
            messages and processing them in a separate thread. You should wrap targets
            that spend a non-trivial amount of time in their Write() method with asynchronous
            target to speed up logging.
            </p>
            <p>
            Because asynchronous logging is quite a common scenario, NLog supports a
            shorthand notation for wrapping all targets with AsyncWrapper. Just add async="true" to
            the &lt;targets/&gt; element in the configuration file.
            </p>
            <code lang="XML">
            <![CDATA[
            <targets async="true">
               ... your targets go here ...
            </targets>
            ]]></code>
            </remarks>
            <example>
            <p>
            To set up the target in the <a href="https://github.com/NLog/NLog/wiki/Configuration-file">configuration file</a>,
            use the following syntax:
            </p>
            <code lang="XML" source="examples/targets/Configuration File/AsyncWrapper/NLog.config" />
            <p>
            To set up the log target programmatically use code like this:
            </p>
            <code lang="C#" source="examples/targets/Configuration API/AsyncWrapper/Wrapping File/Example.cs" />
            </example>
        </member>
        <member name="M:NLog.Targets.Wrappers.AsyncTargetWrapper.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.Wrappers.AsyncTargetWrapper" /> class.
            </summary>
        </member>
        <member name="M:NLog.Targets.Wrappers.AsyncTargetWrapper.#ctor(System.String,NLog.Targets.Target)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.Wrappers.AsyncTargetWrapper" /> class.
            </summary>
            <param name="name">Name of the target.</param>
            <param name="wrappedTarget">The wrapped target.</param>
        </member>
        <member name="M:NLog.Targets.Wrappers.AsyncTargetWrapper.#ctor(NLog.Targets.Target)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.Wrappers.AsyncTargetWrapper" /> class.
            </summary>
            <param name="wrappedTarget">The wrapped target.</param>
        </member>
        <member name="M:NLog.Targets.Wrappers.AsyncTargetWrapper.#ctor(NLog.Targets.Target,System.Int32,NLog.Targets.Wrappers.AsyncTargetWrapperOverflowAction)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.Wrappers.AsyncTargetWrapper" /> class.
            </summary>
            <param name="wrappedTarget">The wrapped target.</param>
            <param name="queueLimit">Maximum number of requests in the queue.</param>
            <param name="overflowAction">The action to be taken when the queue overflows.</param>
        </member>
        <member name="P:NLog.Targets.Wrappers.AsyncTargetWrapper.BatchSize">
            <summary>
            Gets or sets the number of log events that should be processed in a batch
            by the lazy writer thread.
            </summary>
            <docgen category='Buffering Options' order='100' />
        </member>
        <member name="P:NLog.Targets.Wrappers.AsyncTargetWrapper.TimeToSleepBetweenBatches">
            <summary>
            Gets or sets the time in milliseconds to sleep between batches. (1 or less means trigger on new activity)
            </summary>
            <docgen category='Buffering Options' order='100' />
        </member>
        <member name="E:NLog.Targets.Wrappers.AsyncTargetWrapper.LogEventDropped">
            <summary>
            Occurs when LogEvent has been dropped, because internal queue is full and <see cref="P:NLog.Targets.Wrappers.AsyncTargetWrapper.OverflowAction"/> set to <see cref="F:NLog.Targets.Wrappers.AsyncTargetWrapperOverflowAction.Discard"/>
            </summary>
        </member>
        <member name="E:NLog.Targets.Wrappers.AsyncTargetWrapper.EventQueueGrow">
            <summary>
            Occurs when internal queue size is growing, because internal queue is full and <see cref="P:NLog.Targets.Wrappers.AsyncTargetWrapper.OverflowAction"/> set to <see cref="F:NLog.Targets.Wrappers.AsyncTargetWrapperOverflowAction.Grow"/>
            </summary>
        </member>
        <member name="P:NLog.Targets.Wrappers.AsyncTargetWrapper.OverflowAction">
            <summary>
            Gets or sets the action to be taken when the lazy writer thread request queue count
            exceeds the set limit.
            </summary>
            <docgen category='Buffering Options' order='10' />
        </member>
        <member name="P:NLog.Targets.Wrappers.AsyncTargetWrapper.QueueLimit">
            <summary>
            Gets or sets the limit on the number of requests in the lazy writer thread request queue.
            </summary>
            <docgen category='Buffering Options' order='10' />
        </member>
        <member name="P:NLog.Targets.Wrappers.AsyncTargetWrapper.FullBatchSizeWriteLimit">
            <summary>
            Gets or sets the number of batches of <see cref="P:NLog.Targets.Wrappers.AsyncTargetWrapper.BatchSize"/> to write before yielding into <see cref="P:NLog.Targets.Wrappers.AsyncTargetWrapper.TimeToSleepBetweenBatches"/>
            </summary>
            <remarks>
            Performance is better when writing many small batches, than writing a single large batch
            </remarks>
            <docgen category='Buffering Options' order='100' />
        </member>
        <member name="P:NLog.Targets.Wrappers.AsyncTargetWrapper.ForceLockingQueue">
            <summary>
            Gets or sets whether to use the locking queue, instead of a lock-free concurrent queue
            </summary>
            <remarks>
            The locking queue is less concurrent when many logger threads, but reduces memory allocation
            </remarks>
            <docgen category='Buffering Options' order='100' />
        </member>
        <member name="F:NLog.Targets.Wrappers.AsyncTargetWrapper._requestQueue">
            <summary>
            Gets the queue of lazy writer thread requests.
            </summary>
        </member>
        <member name="M:NLog.Targets.Wrappers.AsyncTargetWrapper.FlushAsync(NLog.Common.AsyncContinuation)">
            <summary>
            Schedules a flush of pending events in the queue (if any), followed by flushing the WrappedTarget.
            </summary>
            <param name="asyncContinuation">The asynchronous continuation.</param>
        </member>
        <member name="M:NLog.Targets.Wrappers.AsyncTargetWrapper.InitializeTarget">
            <summary>
            Initializes the target by starting the lazy writer timer.
            </summary>
        </member>
        <member name="M:NLog.Targets.Wrappers.AsyncTargetWrapper.CloseTarget">
            <summary>
            Shuts down the lazy writer timer.
            </summary>
        </member>
        <member name="M:NLog.Targets.Wrappers.AsyncTargetWrapper.StartLazyWriterTimer">
            <summary>
            Starts the lazy writer thread which periodically writes
            queued log messages.
            </summary>
        </member>
        <member name="M:NLog.Targets.Wrappers.AsyncTargetWrapper.StartInstantWriterTimer">
            <summary>
            Attempts to start an instant timer-worker-thread which can write
            queued log messages.
            </summary>
            <returns>Returns true when scheduled a timer-worker-thread</returns>
        </member>
        <member name="M:NLog.Targets.Wrappers.AsyncTargetWrapper.StopLazyWriterThread">
            <summary>
            Stops the lazy writer thread.
            </summary>
        </member>
        <member name="M:NLog.Targets.Wrappers.AsyncTargetWrapper.Write(NLog.Common.AsyncLogEventInfo)">
            <summary>
            Adds the log event to asynchronous queue to be processed by
            the lazy writer thread.
            </summary>
            <param name="logEvent">The log event.</param>
            <remarks>
            The <see cref="M:NLog.Targets.Target.PrecalculateVolatileLayouts(NLog.LogEventInfo)"/> is called
            to ensure that the log event can be processed in another thread.
            </remarks>
        </member>
        <member name="M:NLog.Targets.Wrappers.AsyncTargetWrapper.WriteAsyncThreadSafe(NLog.Common.AsyncLogEventInfo)">
            <summary>
            Write to queue without locking <see cref="P:NLog.Targets.Target.SyncRoot"/>
            </summary>
            <param name="logEvent"></param>
        </member>
        <member name="T:NLog.Targets.Wrappers.AsyncTargetWrapperOverflowAction">
            <summary>
            The action to be taken when the queue overflows.
            </summary>
        </member>
        <member name="F:NLog.Targets.Wrappers.AsyncTargetWrapperOverflowAction.Grow">
            <summary>
            Grow the queue.
            </summary>
        </member>
        <member name="F:NLog.Targets.Wrappers.AsyncTargetWrapperOverflowAction.Discard">
            <summary>
            Discard the overflowing item.
            </summary>
        </member>
        <member name="F:NLog.Targets.Wrappers.AsyncTargetWrapperOverflowAction.Block">
            <summary>
            Block until there's more room in the queue.
            </summary>
        </member>
        <member name="T:NLog.Targets.Wrappers.AutoFlushTargetWrapper">
            <summary>
            Causes a flush on a wrapped target if LogEvent satisfies the <see cref="P:NLog.Targets.Wrappers.AutoFlushTargetWrapper.Condition"/>.
            If condition isn't set, flushes on each write.
            </summary>
            <remarks>
            <a href="https://github.com/nlog/nlog/wiki/AutoFlushWrapper-target">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/nlog/nlog/wiki/AutoFlushWrapper-target">Documentation on NLog Wiki</seealso>
            <example>
            <p>
            To set up the target in the <a href="https://github.com/NLog/NLog/wiki/Configuration-file">configuration file</a>,
            use the following syntax:
            </p>
            <code lang="XML" source="examples/targets/Configuration File/AutoFlushWrapper/NLog.config" />
            <p>
            To set up the log target programmatically use code like this:
            </p>
            <code lang="C#" source="examples/targets/Configuration API/AutoFlushWrapper/Simple/Example.cs" />
            </example>
        </member>
        <member name="P:NLog.Targets.Wrappers.AutoFlushTargetWrapper.Condition">
            <summary>
            Gets or sets the condition expression. Log events who meet this condition will cause
            a flush on the wrapped target.
            </summary>
            <docgen category='General Options' order='10' />
        </member>
        <member name="P:NLog.Targets.Wrappers.AutoFlushTargetWrapper.AsyncFlush">
            <summary>
            Delay the flush until the LogEvent has been confirmed as written
            </summary>
            <remarks>If not explicitly set, then disabled by default for <see cref="T:NLog.Targets.Wrappers.BufferingTargetWrapper"/> and AsyncTaskTarget
            </remarks>
            <docgen category='General Options' order='10' />
        </member>
        <member name="P:NLog.Targets.Wrappers.AutoFlushTargetWrapper.FlushOnConditionOnly">
            <summary>
            Only flush when LogEvent matches condition. Ignore explicit-flush, config-reload-flush and shutdown-flush
            </summary>
            <docgen category='General Options' order='10' />
        </member>
        <member name="M:NLog.Targets.Wrappers.AutoFlushTargetWrapper.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.Wrappers.AutoFlushTargetWrapper" /> class.
            </summary>
        </member>
        <member name="M:NLog.Targets.Wrappers.AutoFlushTargetWrapper.#ctor(System.String,NLog.Targets.Target)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.Wrappers.AutoFlushTargetWrapper" /> class.
            </summary>
            <param name="wrappedTarget">The wrapped target.</param>
            <param name="name">Name of the target</param>
        </member>
        <member name="M:NLog.Targets.Wrappers.AutoFlushTargetWrapper.#ctor(NLog.Targets.Target)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.Wrappers.AutoFlushTargetWrapper" /> class.
            </summary>
            <param name="wrappedTarget">The wrapped target.</param>
        </member>
        <member name="M:NLog.Targets.Wrappers.AutoFlushTargetWrapper.InitializeTarget">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Targets.Wrappers.AutoFlushTargetWrapper.Write(NLog.Common.AsyncLogEventInfo)">
            <summary>
            Forwards the call to the <see cref="P:NLog.Targets.Wrappers.WrapperTargetBase.WrappedTarget"/>.Write()
            and calls <see cref="M:NLog.Targets.Target.Flush(NLog.Common.AsyncContinuation)"/> on it if LogEvent satisfies
            the flush condition or condition is null.
            </summary>
            <param name="logEvent">Logging event to be written out.</param>
        </member>
        <member name="M:NLog.Targets.Wrappers.AutoFlushTargetWrapper.FlushAsync(NLog.Common.AsyncContinuation)">
            <summary>
            Schedules a flush operation, that triggers when all pending flush operations are completed (in case of asynchronous targets).
            </summary>
            <param name="asyncContinuation">The asynchronous continuation.</param>
        </member>
        <member name="M:NLog.Targets.Wrappers.AutoFlushTargetWrapper.CloseTarget">
            <inheritdoc/>
        </member>
        <member name="T:NLog.Targets.Wrappers.BufferingTargetWrapper">
            <summary>
            A target that buffers log events and sends them in batches to the wrapped target.
            </summary>
            <remarks>
            <a href="https://github.com/nlog/nlog/wiki/BufferingWrapper-target">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/nlog/nlog/wiki/BufferingWrapper-target">Documentation on NLog Wiki</seealso>
        </member>
        <member name="M:NLog.Targets.Wrappers.BufferingTargetWrapper.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.Wrappers.BufferingTargetWrapper" /> class.
            </summary>
        </member>
        <member name="M:NLog.Targets.Wrappers.BufferingTargetWrapper.#ctor(System.String,NLog.Targets.Target)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.Wrappers.BufferingTargetWrapper" /> class.
            </summary>
            <param name="name">Name of the target.</param>
            <param name="wrappedTarget">The wrapped target.</param>
        </member>
        <member name="M:NLog.Targets.Wrappers.BufferingTargetWrapper.#ctor(NLog.Targets.Target)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.Wrappers.BufferingTargetWrapper" /> class.
            </summary>
            <param name="wrappedTarget">The wrapped target.</param>
        </member>
        <member name="M:NLog.Targets.Wrappers.BufferingTargetWrapper.#ctor(NLog.Targets.Target,System.Int32)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.Wrappers.BufferingTargetWrapper" /> class.
            </summary>
            <param name="wrappedTarget">The wrapped target.</param>
            <param name="bufferSize">Size of the buffer.</param>
        </member>
        <member name="M:NLog.Targets.Wrappers.BufferingTargetWrapper.#ctor(NLog.Targets.Target,System.Int32,System.Int32)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.Wrappers.BufferingTargetWrapper" /> class.
            </summary>
            <param name="wrappedTarget">The wrapped target.</param>
            <param name="bufferSize">Size of the buffer.</param>
            <param name="flushTimeout">The flush timeout.</param>
        </member>
        <member name="M:NLog.Targets.Wrappers.BufferingTargetWrapper.#ctor(NLog.Targets.Target,System.Int32,System.Int32,NLog.Targets.Wrappers.BufferingTargetWrapperOverflowAction)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.Wrappers.BufferingTargetWrapper" /> class.
            </summary>
            <param name="wrappedTarget">The wrapped target.</param>
            <param name="bufferSize">Size of the buffer.</param>
            <param name="flushTimeout">The flush timeout.</param>
            <param name="overflowAction">The action to take when the buffer overflows.</param>
        </member>
        <member name="P:NLog.Targets.Wrappers.BufferingTargetWrapper.BufferSize">
            <summary>
            Gets or sets the number of log events to be buffered.
            </summary>
            <docgen category='Buffering Options' order='10' />
        </member>
        <member name="P:NLog.Targets.Wrappers.BufferingTargetWrapper.FlushTimeout">
            <summary>
            Gets or sets the timeout (in milliseconds) after which the contents of buffer will be flushed
            if there's no write in the specified period of time. Use -1 to disable timed flushes.
            </summary>
            <docgen category='Buffering Options' order='100' />
        </member>
        <member name="P:NLog.Targets.Wrappers.BufferingTargetWrapper.SlidingTimeout">
            <summary>
            Gets or sets a value indicating whether to use sliding timeout.
            </summary>
            <remarks>
            This value determines how the inactivity period is determined. If sliding timeout is enabled,
            the inactivity timer is reset after each write, if it is disabled - inactivity timer will
            count from the first event written to the buffer.
            </remarks>
            <docgen category='Buffering Options' order='100' />
        </member>
        <member name="P:NLog.Targets.Wrappers.BufferingTargetWrapper.OverflowAction">
            <summary>
            Gets or sets the action to take if the buffer overflows.
            </summary>
            <remarks>
            Setting to <see cref="F:NLog.Targets.Wrappers.BufferingTargetWrapperOverflowAction.Discard"/> will replace the
            oldest event with new events without sending events down to the wrapped target, and
            setting to <see cref="F:NLog.Targets.Wrappers.BufferingTargetWrapperOverflowAction.Flush"/> will flush the
            entire buffer to the wrapped target.
            </remarks>
            <docgen category='Buffering Options' order='50' />
        </member>
        <member name="M:NLog.Targets.Wrappers.BufferingTargetWrapper.FlushAsync(NLog.Common.AsyncContinuation)">
            <summary>
            Flushes pending events in the buffer (if any), followed by flushing the WrappedTarget.
            </summary>
            <param name="asyncContinuation">The asynchronous continuation.</param>
        </member>
        <member name="M:NLog.Targets.Wrappers.BufferingTargetWrapper.InitializeTarget">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Targets.Wrappers.BufferingTargetWrapper.CloseTarget">
            <summary>
            Closes the target by flushing pending events in the buffer (if any).
            </summary>
        </member>
        <member name="M:NLog.Targets.Wrappers.BufferingTargetWrapper.Write(NLog.Common.AsyncLogEventInfo)">
            <summary>
            Adds the specified log event to the buffer and flushes
            the buffer in case the buffer gets full.
            </summary>
            <param name="logEvent">The log event.</param>
        </member>
        <member name="T:NLog.Targets.Wrappers.BufferingTargetWrapperOverflowAction">
            <summary>
            The action to be taken when the buffer overflows.
            </summary>
        </member>
        <member name="F:NLog.Targets.Wrappers.BufferingTargetWrapperOverflowAction.Flush">
            <summary>
            Flush the content of the buffer.
            </summary>
        </member>
        <member name="F:NLog.Targets.Wrappers.BufferingTargetWrapperOverflowAction.Discard">
            <summary>
            Discard the oldest item.
            </summary>
        </member>
        <member name="T:NLog.Targets.Wrappers.CompoundTargetBase">
            <summary>
            A base class for targets which wrap other (multiple) targets
            and provide various forms of target routing.
            </summary>
        </member>
        <member name="M:NLog.Targets.Wrappers.CompoundTargetBase.#ctor(NLog.Targets.Target[])">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.Wrappers.CompoundTargetBase" /> class.
            </summary>
            <param name="targets">The targets.</param>
        </member>
        <member name="P:NLog.Targets.Wrappers.CompoundTargetBase.Targets">
            <summary>
            Gets the collection of targets managed by this compound target.
            </summary>
        </member>
        <member name="M:NLog.Targets.Wrappers.CompoundTargetBase.ToString">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Targets.Wrappers.CompoundTargetBase.Write(NLog.LogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Targets.Wrappers.CompoundTargetBase.FlushAsync(NLog.Common.AsyncContinuation)">
            <summary>
            Flush any pending log messages for all wrapped targets.
            </summary>
            <param name="asyncContinuation">The asynchronous continuation.</param>
        </member>
        <member name="T:NLog.Targets.Wrappers.ConcurrentRequestQueue">
            <summary>
            Concurrent Asynchronous request queue based on <see cref="T:System.Collections.Concurrent.ConcurrentQueue`1"/>
            </summary>
        </member>
        <member name="M:NLog.Targets.Wrappers.ConcurrentRequestQueue.#ctor(System.Int32,NLog.Targets.Wrappers.AsyncTargetWrapperOverflowAction)">
            <summary>
            Initializes a new instance of the AsyncRequestQueue class.
            </summary>
            <param name="requestLimit">Request limit.</param>
            <param name="overflowAction">The overflow action.</param>
        </member>
        <member name="P:NLog.Targets.Wrappers.ConcurrentRequestQueue.Count">
            <summary>
            Gets the number of requests currently in the queue.
            </summary>
            <remarks>
            Only for debugging purposes
            </remarks>
        </member>
        <member name="M:NLog.Targets.Wrappers.ConcurrentRequestQueue.Enqueue(NLog.Common.AsyncLogEventInfo)">
            <summary>
            Enqueues another item. If the queue is overflown the appropriate
            action is taken as specified by <see cref="P:NLog.Targets.Wrappers.AsyncRequestQueueBase.OnOverflow"/>.
            </summary>
            <param name="logEventInfo">The log event info.</param>
            <returns>Queue was empty before enqueue</returns>
        </member>
        <member name="M:NLog.Targets.Wrappers.ConcurrentRequestQueue.DequeueBatch(System.Int32)">
            <summary>
            Dequeues a maximum of <c>count</c> items from the queue
            and adds returns the list containing them.
            </summary>
            <param name="count">Maximum number of items to be dequeued</param>
            <returns>The array of log events.</returns>
        </member>
        <member name="M:NLog.Targets.Wrappers.ConcurrentRequestQueue.DequeueBatch(System.Int32,System.Collections.Generic.IList{NLog.Common.AsyncLogEventInfo})">
            <summary>
            Dequeues into a preallocated array, instead of allocating a new one
            </summary>
            <param name="count">Maximum number of items to be dequeued</param>
            <param name="result">Preallocated list</param>
        </member>
        <member name="M:NLog.Targets.Wrappers.ConcurrentRequestQueue.Clear">
            <summary>
            Clears the queue.
            </summary>
        </member>
        <member name="T:NLog.Targets.Wrappers.FallbackGroupTarget">
            <summary>
            Provides fallback-on-error.
            </summary>
            <remarks>
            <a href="https://github.com/nlog/nlog/wiki/FallbackGroup-target">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/nlog/nlog/wiki/FallbackGroup-target">Documentation on NLog Wiki</seealso>
            <example>
            <p>This example causes the messages to be written to server1,
            and if it fails, messages go to server2.</p>
            <p>
            To set up the target in the <a href="https://github.com/NLog/NLog/wiki/Configuration-file">configuration file</a>,
            use the following syntax:
            </p>
            <code lang="XML" source="examples/targets/Configuration File/FallbackGroup/NLog.config" />
            <p>
            To set up the log target programmatically use code like this:
            </p>
            <code lang="C#" source="examples/targets/Configuration API/FallbackGroup/Simple/Example.cs" />
            </example>
        </member>
        <member name="M:NLog.Targets.Wrappers.FallbackGroupTarget.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.Wrappers.FallbackGroupTarget"/> class.
            </summary>
        </member>
        <member name="M:NLog.Targets.Wrappers.FallbackGroupTarget.#ctor(System.String,NLog.Targets.Target[])">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.Wrappers.FallbackGroupTarget"/> class.
            </summary>
            <param name="name">Name of the target.</param>
            <param name="targets">The targets.</param>
        </member>
        <member name="M:NLog.Targets.Wrappers.FallbackGroupTarget.#ctor(NLog.Targets.Target[])">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.Wrappers.FallbackGroupTarget" /> class.
            </summary>
            <param name="targets">The targets.</param>
        </member>
        <member name="P:NLog.Targets.Wrappers.FallbackGroupTarget.ReturnToFirstOnSuccess">
            <summary>
            Gets or sets a value indicating whether to return to the first target after any successful write.
            </summary>
            <docgen category='Fallback Options' order='10' />
        </member>
        <member name="P:NLog.Targets.Wrappers.FallbackGroupTarget.EnableBatchWrite">
            <summary>
            Gets or sets whether to enable batching, but fallback will be handled individually
            </summary>
            <docgen category='Fallback Options' order='50' />
        </member>
        <member name="M:NLog.Targets.Wrappers.FallbackGroupTarget.WriteAsyncThreadSafe(System.Collections.Generic.IList{NLog.Common.AsyncLogEventInfo})">
            <summary>
            Forwards the log event to the sub-targets until one of them succeeds.
            </summary>
            <param name="logEvents">The log event.</param>
        </member>
        <member name="M:NLog.Targets.Wrappers.FallbackGroupTarget.WriteAsyncThreadSafe(NLog.Common.AsyncLogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Targets.Wrappers.FallbackGroupTarget.Write(NLog.Common.AsyncLogEventInfo)">
            <summary>
            Forwards the log event to the sub-targets until one of them succeeds.
            </summary>
        </member>
        <member name="T:NLog.Targets.Wrappers.FilteringRule">
            <summary>
            Filtering rule for <see cref="T:NLog.Targets.Wrappers.PostFilteringTargetWrapper"/>.
            </summary>
        </member>
        <member name="M:NLog.Targets.Wrappers.FilteringRule.#ctor">
            <summary>
            Initializes a new instance of the FilteringRule class.
            </summary>
        </member>
        <member name="M:NLog.Targets.Wrappers.FilteringRule.#ctor(NLog.Conditions.ConditionExpression,NLog.Conditions.ConditionExpression)">
            <summary>
            Initializes a new instance of the FilteringRule class.
            </summary>
            <param name="whenExistsExpression">Condition to be tested against all events.</param>
            <param name="filterToApply">Filter to apply to all log events when the first condition matches any of them.</param>
        </member>
        <member name="P:NLog.Targets.Wrappers.FilteringRule.Exists">
            <summary>
            Gets or sets the condition to be tested.
            </summary>
            <docgen category='Filtering Options' order='10' />
        </member>
        <member name="P:NLog.Targets.Wrappers.FilteringRule.Filter">
            <summary>
            Gets or sets the resulting filter to be applied when the condition matches.
            </summary>
            <docgen category='Filtering Options' order='10' />
        </member>
        <member name="T:NLog.Targets.Wrappers.FilteringTargetWrapper">
            <summary>
            Filters log entries based on a condition.
            </summary>
            <remarks>
            <a href="https://github.com/nlog/nlog/wiki/FilteringWrapper-target">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/nlog/nlog/wiki/FilteringWrapper-target">Documentation on NLog Wiki</seealso>
            <example>
            <p>This example causes the messages not contains the string '1' to be ignored.</p>
            <p>
            To set up the target in the <a href="https://github.com/NLog/NLog/wiki/Configuration-file">configuration file</a>,
            use the following syntax:
            </p>
            <code lang="XML" source="examples/targets/Configuration File/FilteringWrapper/NLog.config" />
            <p>
            To set up the log target programmatically use code like this:
            </p>
            <code lang="C#" source="examples/targets/Configuration API/FilteringWrapper/Simple/Example.cs" />
            </example>
        </member>
        <member name="M:NLog.Targets.Wrappers.FilteringTargetWrapper.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.Wrappers.FilteringTargetWrapper" /> class.
            </summary>
        </member>
        <member name="M:NLog.Targets.Wrappers.FilteringTargetWrapper.#ctor(System.String,NLog.Targets.Target,NLog.Conditions.ConditionExpression)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.Wrappers.FilteringTargetWrapper" /> class.
            </summary>
            <param name="name">Name of the target.</param>
            <param name="wrappedTarget">The wrapped target.</param>
            <param name="condition">The condition.</param>
        </member>
        <member name="M:NLog.Targets.Wrappers.FilteringTargetWrapper.#ctor(NLog.Targets.Target,NLog.Conditions.ConditionExpression)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.Wrappers.FilteringTargetWrapper" /> class.
            </summary>
            <param name="wrappedTarget">The wrapped target.</param>
            <param name="condition">The condition.</param>
        </member>
        <member name="P:NLog.Targets.Wrappers.FilteringTargetWrapper.Condition">
            <summary>
            Gets or sets the condition expression. Log events who meet this condition will be forwarded
            to the wrapped target.
            </summary>
            <docgen category='Filtering Options' order='10' />
        </member>
        <member name="P:NLog.Targets.Wrappers.FilteringTargetWrapper.Filter">
            <summary>
            Gets or sets the filter. Log events who evaluates to <see cref="F:NLog.Filters.FilterResult.Ignore"/> will be discarded
            </summary>
            <docgen category='Filtering Options' order='10' />
        </member>
        <member name="M:NLog.Targets.Wrappers.FilteringTargetWrapper.Write(NLog.Common.AsyncLogEventInfo)">
            <summary>
            Checks the condition against the passed log event.
            If the condition is met, the log event is forwarded to
            the wrapped target.
            </summary>
            <param name="logEvent">Log event.</param>
        </member>
        <member name="M:NLog.Targets.Wrappers.FilteringTargetWrapper.Write(System.Collections.Generic.IList{NLog.Common.AsyncLogEventInfo})">
            <inheritdoc/>
        </member>
        <member name="T:NLog.Targets.Wrappers.GroupByTargetWrapper">
            <summary>
            A target that buffers log events and sends them in batches to the wrapped target.
            </summary>
            <remarks>
            <a href="https://github.com/nlog/nlog/wiki/GroupByWrapper-target">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/GroupByWrapper-target">Documentation on NLog Wiki</seealso>
        </member>
        <member name="P:NLog.Targets.Wrappers.GroupByTargetWrapper.Key">
            <summary>
            Identifier to perform group-by
            </summary>
        </member>
        <member name="M:NLog.Targets.Wrappers.GroupByTargetWrapper.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.Wrappers.GroupByTargetWrapper" /> class.
            </summary>
        </member>
        <member name="M:NLog.Targets.Wrappers.GroupByTargetWrapper.#ctor(NLog.Targets.Target)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.Wrappers.GroupByTargetWrapper" /> class.
            </summary>
            <param name="wrappedTarget">The wrapped target.</param>
        </member>
        <member name="M:NLog.Targets.Wrappers.GroupByTargetWrapper.#ctor(System.String,NLog.Targets.Target)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.Wrappers.GroupByTargetWrapper" /> class.
            </summary>
            <param name="name">The name of the target.</param>
            <param name="wrappedTarget">The wrapped target.</param>
        </member>
        <member name="M:NLog.Targets.Wrappers.GroupByTargetWrapper.#ctor(System.String,NLog.Targets.Target,NLog.Layouts.Layout)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.Wrappers.GroupByTargetWrapper" /> class.
            </summary>
            <param name="name">The name of the target.</param>
            <param name="wrappedTarget">The wrapped target.</param>
            <param name="key">Group by identifier.</param>
        </member>
        <member name="M:NLog.Targets.Wrappers.GroupByTargetWrapper.Write(NLog.Common.AsyncLogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Targets.Wrappers.GroupByTargetWrapper.Write(System.Collections.Generic.IList{NLog.Common.AsyncLogEventInfo})">
            <inheritdoc/>
        </member>
        <member name="T:NLog.Targets.Wrappers.LimitingTargetWrapper">
            <summary>
            Limits the number of messages written per timespan to the wrapped target.
            </summary>
            <remarks>
            <a href="https://github.com/nlog/nlog/wiki/LimitingWrapper-target">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/NLog/NLog/wiki/LimitingWrapper-target">Documentation on NLog Wiki</seealso>
        </member>
        <member name="M:NLog.Targets.Wrappers.LimitingTargetWrapper.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.Wrappers.LimitingTargetWrapper" /> class.
            </summary>
        </member>
        <member name="M:NLog.Targets.Wrappers.LimitingTargetWrapper.#ctor(System.String,NLog.Targets.Target)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.Wrappers.LimitingTargetWrapper" /> class.
            </summary>
            <param name="name">The name of the target.</param>
            <param name="wrappedTarget">The wrapped target.</param>
        </member>
        <member name="M:NLog.Targets.Wrappers.LimitingTargetWrapper.#ctor(NLog.Targets.Target)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.Wrappers.LimitingTargetWrapper" /> class.
            </summary>
            <param name="wrappedTarget">The wrapped target.</param>
        </member>
        <member name="M:NLog.Targets.Wrappers.LimitingTargetWrapper.#ctor(NLog.Targets.Target,System.Int32,System.TimeSpan)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.Wrappers.LimitingTargetWrapper" /> class.
            </summary>
            <param name="wrappedTarget">The wrapped target.</param>
            <param name="messageLimit">Maximum number of messages written per interval.</param>
            <param name="interval">Interval in which the maximum number of messages can be written.</param>
        </member>
        <member name="P:NLog.Targets.Wrappers.LimitingTargetWrapper.MessageLimit">
            <summary>
            Gets or sets the maximum allowed number of messages written per <see cref="P:NLog.Targets.Wrappers.LimitingTargetWrapper.Interval"/>.
            </summary>
            <remarks>
            Messages received after <see cref="P:NLog.Targets.Wrappers.LimitingTargetWrapper.MessageLimit"/> has been reached in the current <see cref="P:NLog.Targets.Wrappers.LimitingTargetWrapper.Interval"/> will be discarded.
            </remarks>
            <docgen category='General Options' order='10' />
        </member>
        <member name="P:NLog.Targets.Wrappers.LimitingTargetWrapper.Interval">
            <summary>
            Gets or sets the interval in which messages will be written up to the <see cref="P:NLog.Targets.Wrappers.LimitingTargetWrapper.MessageLimit"/> number of messages.
            </summary>
            <remarks>
            Messages received after <see cref="P:NLog.Targets.Wrappers.LimitingTargetWrapper.MessageLimit"/> has been reached in the current <see cref="P:NLog.Targets.Wrappers.LimitingTargetWrapper.Interval"/> will be discarded.
            </remarks>
            <docgen category='General Options' order='10' />
        </member>
        <member name="P:NLog.Targets.Wrappers.LimitingTargetWrapper.MessagesWrittenCount">
            <summary>
            Gets the number of <see cref="T:NLog.Common.AsyncLogEventInfo"/> written in the current <see cref="P:NLog.Targets.Wrappers.LimitingTargetWrapper.Interval"/>.
            </summary>
            <docgen category='General Options' order='10' />
        </member>
        <member name="M:NLog.Targets.Wrappers.LimitingTargetWrapper.InitializeTarget">
            <summary>
            Initializes the target and resets the current Interval and <see cref="P:NLog.Targets.Wrappers.LimitingTargetWrapper.MessagesWrittenCount"/>.
             </summary>
        </member>
        <member name="M:NLog.Targets.Wrappers.LimitingTargetWrapper.Write(NLog.Common.AsyncLogEventInfo)">
            <summary>
            Writes log event to the wrapped target if the current <see cref="P:NLog.Targets.Wrappers.LimitingTargetWrapper.MessagesWrittenCount"/> is lower than <see cref="P:NLog.Targets.Wrappers.LimitingTargetWrapper.MessageLimit"/>.
            If the <see cref="P:NLog.Targets.Wrappers.LimitingTargetWrapper.MessageLimit"/> is already reached, no log event will be written to the wrapped target.
            <see cref="P:NLog.Targets.Wrappers.LimitingTargetWrapper.MessagesWrittenCount"/> resets when the current <see cref="P:NLog.Targets.Wrappers.LimitingTargetWrapper.Interval"/> is expired.
            </summary>
            <param name="logEvent">Log event to be written out.</param>
        </member>
        <member name="T:NLog.Targets.Wrappers.LogEventDroppedEventArgs">
            <summary>
            Arguments for <see cref="E:NLog.Targets.Wrappers.AsyncTargetWrapper.LogEventDropped"/> events.
            </summary>
        </member>
        <member name="M:NLog.Targets.Wrappers.LogEventDroppedEventArgs.#ctor(NLog.LogEventInfo)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.Wrappers.LogEventDroppedEventArgs" /> class.
            </summary>
            <param name="logEventInfo">LogEvent that have been dropped</param>
        </member>
        <member name="P:NLog.Targets.Wrappers.LogEventDroppedEventArgs.DroppedLogEventInfo">
            <summary>
            Instance of <see cref="T:NLog.LogEventInfo"/> that was dropped by <see cref="T:NLog.Targets.Target"/>
            </summary>
        </member>
        <member name="T:NLog.Targets.Wrappers.LogEventQueueGrowEventArgs">
            <summary>
            Raises by  <see cref="T:NLog.Targets.Wrappers.AsyncRequestQueue"/> when
            queue is full
            and <see cref="P:NLog.Targets.Wrappers.AsyncRequestQueueBase.OnOverflow"/> set to <see cref="F:NLog.Targets.Wrappers.AsyncTargetWrapperOverflowAction.Grow"/>
            By default queue doubles it size.
            </summary>
        </member>
        <member name="M:NLog.Targets.Wrappers.LogEventQueueGrowEventArgs.#ctor(System.Int64,System.Int64)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.Wrappers.LogEventQueueGrowEventArgs" /> class.
            </summary>
            <param name="newQueueSize">Required queue size</param>
            <param name="requestsCount">Current queue size</param>
        </member>
        <member name="P:NLog.Targets.Wrappers.LogEventQueueGrowEventArgs.NewQueueSize">
            <summary>
            New queue size
            </summary>
        </member>
        <member name="P:NLog.Targets.Wrappers.LogEventQueueGrowEventArgs.RequestsCount">
            <summary>
            Current requests count
            </summary>
        </member>
        <member name="T:NLog.Targets.Wrappers.PostFilteringTargetWrapper">
            <summary>
            Filters buffered log entries based on a set of conditions that are evaluated on a group of events.
            </summary>
            <remarks>
            <a href="https://github.com/nlog/nlog/wiki/PostFilteringWrapper-target">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/nlog/nlog/wiki/PostFilteringWrapper-target">Documentation on NLog Wiki</seealso>
            <example>
            <p>
            This example works like this. If there are no Warn,Error or Fatal messages in the buffer
            only Info messages are written to the file, but if there are any warnings or errors,
            the output includes detailed trace (levels &gt;= Debug).
            </p>
            <p>
            To set up the target in the <a href="https://github.com/NLog/NLog/wiki/Configuration-file">configuration file</a>,
            use the following syntax:
            </p>
            <code lang="XML" source="examples/targets/Configuration File/PostFilteringWrapper/NLog.config" />
            <p>
            To set up the log target programmatically use code like this:
            </p>
            <code lang="C#" source="examples/targets/Configuration API/PostFilteringWrapper/Simple/Example.cs" />
            </example>
        </member>
        <member name="M:NLog.Targets.Wrappers.PostFilteringTargetWrapper.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.Wrappers.PostFilteringTargetWrapper" /> class.
            </summary>
        </member>
        <member name="M:NLog.Targets.Wrappers.PostFilteringTargetWrapper.#ctor(NLog.Targets.Target)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.Wrappers.PostFilteringTargetWrapper" /> class.
            </summary>
        </member>
        <member name="M:NLog.Targets.Wrappers.PostFilteringTargetWrapper.#ctor(System.String,NLog.Targets.Target)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.Wrappers.PostFilteringTargetWrapper" /> class.
            </summary>
            <param name="name">Name of the target.</param>
            <param name="wrappedTarget">The wrapped target.</param>
        </member>
        <member name="P:NLog.Targets.Wrappers.PostFilteringTargetWrapper.DefaultFilter">
            <summary>
            Gets or sets the default filter to be applied when no specific rule matches.
            </summary>
            <docgen category='Filtering Options' order='10' />
        </member>
        <member name="P:NLog.Targets.Wrappers.PostFilteringTargetWrapper.Rules">
            <summary>
            Gets the collection of filtering rules. The rules are processed top-down
            and the first rule that matches determines the filtering condition to
            be applied to log events.
            </summary>
            <docgen category='Filtering Rules' order='10' />
        </member>
        <member name="M:NLog.Targets.Wrappers.PostFilteringTargetWrapper.Write(NLog.Common.AsyncLogEventInfo)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Targets.Wrappers.PostFilteringTargetWrapper.Write(System.Collections.Generic.IList{NLog.Common.AsyncLogEventInfo})">
            <summary>
            Evaluates all filtering rules to find the first one that matches.
            The matching rule determines the filtering condition to be applied
            to all items in a buffer. If no condition matches, default filter
            is applied to the array of log events.
            </summary>
            <param name="logEvents">Array of log events to be post-filtered.</param>
        </member>
        <member name="M:NLog.Targets.Wrappers.PostFilteringTargetWrapper.EvaluateAllRules(System.Collections.Generic.IList{NLog.Common.AsyncLogEventInfo})">
            <summary>
            Evaluate all the rules to get the filtering condition
            </summary>
            <param name="logEvents"></param>
            <returns></returns>
        </member>
        <member name="T:NLog.Targets.Wrappers.RandomizeGroupTarget">
            <summary>
            Sends log messages to a randomly selected target.
            </summary>
            <remarks>
            <a href="https://github.com/nlog/nlog/wiki/RandomizeGroup-target">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/nlog/nlog/wiki/RandomizeGroup-target">Documentation on NLog Wiki</seealso>
            <example>
            <p>This example causes the messages to be written to either file1.txt or file2.txt
            chosen randomly on a per-message basis.
            </p>
            <p>
            To set up the target in the <a href="https://github.com/NLog/NLog/wiki/Configuration-file">configuration file</a>,
            use the following syntax:
            </p>
            <code lang="XML" source="examples/targets/Configuration File/RandomizeGroup/NLog.config" />
            <p>
            To set up the log target programmatically use code like this:
            </p>
            <code lang="C#" source="examples/targets/Configuration API/RandomizeGroup/Simple/Example.cs" />
            </example>
        </member>
        <member name="M:NLog.Targets.Wrappers.RandomizeGroupTarget.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.Wrappers.RandomizeGroupTarget" /> class.
            </summary>
        </member>
        <member name="M:NLog.Targets.Wrappers.RandomizeGroupTarget.#ctor(System.String,NLog.Targets.Target[])">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.Wrappers.RandomizeGroupTarget" /> class.
            </summary>
            <param name="name">Name of the target.</param>
            <param name="targets">The targets.</param>
        </member>
        <member name="M:NLog.Targets.Wrappers.RandomizeGroupTarget.#ctor(NLog.Targets.Target[])">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.Wrappers.RandomizeGroupTarget" /> class.
            </summary>
            <param name="targets">The targets.</param>
        </member>
        <member name="M:NLog.Targets.Wrappers.RandomizeGroupTarget.Write(NLog.Common.AsyncLogEventInfo)">
            <summary>
            Forwards the log event to one of the sub-targets.
            The sub-target is randomly chosen.
            </summary>
            <param name="logEvent">The log event.</param>
        </member>
        <member name="T:NLog.Targets.Wrappers.RepeatingTargetWrapper">
            <summary>
            Repeats each log event the specified number of times.
            </summary>
            <remarks>
            <a href="https://github.com/nlog/nlog/wiki/RepeatingWrapper-target">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/nlog/nlog/wiki/RepeatingWrapper-target">Documentation on NLog Wiki</seealso>
            <example>
            <p>This example causes each log message to be repeated 3 times.</p>
            <p>
            To set up the target in the <a href="https://github.com/NLog/NLog/wiki/Configuration-file">configuration file</a>,
            use the following syntax:
            </p>
            <code lang="XML" source="examples/targets/Configuration File/RepeatingWrapper/NLog.config" />
            <p>
            To set up the log target programmatically use code like this:
            </p>
            <code lang="C#" source="examples/targets/Configuration API/RepeatingWrapper/Simple/Example.cs" />
            </example>
        </member>
        <member name="M:NLog.Targets.Wrappers.RepeatingTargetWrapper.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.Wrappers.RepeatingTargetWrapper" /> class.
            </summary>
        </member>
        <member name="M:NLog.Targets.Wrappers.RepeatingTargetWrapper.#ctor(System.String,NLog.Targets.Target,System.Int32)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.Wrappers.RepeatingTargetWrapper" /> class.
            </summary>
            <param name="name">Name of the target.</param>
            <param name="wrappedTarget">The wrapped target.</param>
            <param name="repeatCount">The repeat count.</param>
        </member>
        <member name="M:NLog.Targets.Wrappers.RepeatingTargetWrapper.#ctor(NLog.Targets.Target,System.Int32)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.Wrappers.RepeatingTargetWrapper" /> class.
            </summary>
            <param name="wrappedTarget">The wrapped target.</param>
            <param name="repeatCount">The repeat count.</param>
        </member>
        <member name="P:NLog.Targets.Wrappers.RepeatingTargetWrapper.RepeatCount">
            <summary>
            Gets or sets the number of times to repeat each log message.
            </summary>
            <docgen category='Repeating Options' order='10' />
        </member>
        <member name="M:NLog.Targets.Wrappers.RepeatingTargetWrapper.Write(NLog.Common.AsyncLogEventInfo)">
            <summary>
            Forwards the log message to the <see cref="P:NLog.Targets.Wrappers.WrapperTargetBase.WrappedTarget"/> by calling the <see cref="M:NLog.Targets.Target.Write(NLog.LogEventInfo)"/> method <see cref="P:NLog.Targets.Wrappers.RepeatingTargetWrapper.RepeatCount"/> times.
            </summary>
            <param name="logEvent">The log event.</param>
        </member>
        <member name="T:NLog.Targets.Wrappers.RetryingTargetWrapper">
            <summary>
            Retries in case of write error.
            </summary>
            <remarks>
            <a href="https://github.com/nlog/nlog/wiki/RetryingWrapper-target">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/nlog/nlog/wiki/RetryingWrapper-target">Documentation on NLog Wiki</seealso>
            <example>
            <p>This example causes each write attempt to be repeated 3 times,
            sleeping 1 second between attempts if first one fails.</p>
            <p>
            To set up the target in the <a href="https://github.com/NLog/NLog/wiki/Configuration-file">configuration file</a>,
            use the following syntax:
            </p>
            <code lang="XML" source="examples/targets/Configuration File/RetryingWrapper/NLog.config" />
            <p>
            To set up the log target programmatically use code like this:
            </p>
            <code lang="C#" source="examples/targets/Configuration API/RetryingWrapper/Simple/Example.cs" />
            </example>
        </member>
        <member name="M:NLog.Targets.Wrappers.RetryingTargetWrapper.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.Wrappers.RetryingTargetWrapper" /> class.
            </summary>
        </member>
        <member name="M:NLog.Targets.Wrappers.RetryingTargetWrapper.#ctor(System.String,NLog.Targets.Target,System.Int32,System.Int32)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.Wrappers.RetryingTargetWrapper" /> class.
            </summary>
            <param name="name">Name of the target.</param>
            <param name="wrappedTarget">The wrapped target.</param>
            <param name="retryCount">The retry count.</param>
            <param name="retryDelayMilliseconds">The retry delay milliseconds.</param>
        </member>
        <member name="M:NLog.Targets.Wrappers.RetryingTargetWrapper.#ctor(NLog.Targets.Target,System.Int32,System.Int32)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.Wrappers.RetryingTargetWrapper" /> class.
            </summary>
            <param name="wrappedTarget">The wrapped target.</param>
            <param name="retryCount">The retry count.</param>
            <param name="retryDelayMilliseconds">The retry delay milliseconds.</param>
        </member>
        <member name="P:NLog.Targets.Wrappers.RetryingTargetWrapper.RetryCount">
            <summary>
            Gets or sets the number of retries that should be attempted on the wrapped target in case of a failure.
            </summary>
            <docgen category='Retrying Options' order='10' />
        </member>
        <member name="P:NLog.Targets.Wrappers.RetryingTargetWrapper.RetryDelayMilliseconds">
            <summary>
            Gets or sets the time to wait between retries in milliseconds.
            </summary>
            <docgen category='Retrying Options' order='10' />
        </member>
        <member name="P:NLog.Targets.Wrappers.RetryingTargetWrapper.EnableBatchWrite">
            <summary>
            Gets or sets whether to enable batching, and only apply single delay when a whole batch fails
            </summary>
            <docgen category='Retrying Options' order='10' />
        </member>
        <member name="F:NLog.Targets.Wrappers.RetryingTargetWrapper._retrySyncObject">
            <summary>
            Special SyncObject to allow closing down Target while busy retrying
            </summary>
        </member>
        <member name="M:NLog.Targets.Wrappers.RetryingTargetWrapper.WriteAsyncThreadSafe(System.Collections.Generic.IList{NLog.Common.AsyncLogEventInfo})">
            <summary>
            Writes the specified log event to the wrapped target, retrying and pausing in case of an error.
            </summary>
            <param name="logEvents">The log event.</param>
        </member>
        <member name="M:NLog.Targets.Wrappers.RetryingTargetWrapper.WriteAsyncThreadSafe(NLog.Common.AsyncLogEventInfo)">
            <summary>
            Writes the specified log event to the wrapped target in a thread-safe manner.
            </summary>
            <param name="logEvent">The log event.</param>
        </member>
        <member name="M:NLog.Targets.Wrappers.RetryingTargetWrapper.Write(NLog.Common.AsyncLogEventInfo)">
            <summary>
            Writes the specified log event to the wrapped target, retrying and pausing in case of an error.
            </summary>
            <param name="logEvent">The log event.</param>
        </member>
        <member name="T:NLog.Targets.Wrappers.RoundRobinGroupTarget">
            <summary>
            Distributes log events to targets in a round-robin fashion.
            </summary>
            <remarks>
            <a href="https://github.com/nlog/nlog/wiki/RoundRobinGroup-target">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/nlog/nlog/wiki/RoundRobinGroup-target">Documentation on NLog Wiki</seealso>
            <example>
            <p>This example causes the messages to be written to either file1.txt or file2.txt.
            Each odd message is written to file2.txt, each even message goes to file1.txt.
            </p>
            <p>
            To set up the target in the <a href="https://github.com/NLog/NLog/wiki/Configuration-file">configuration file</a>,
            use the following syntax:
            </p>
            <code lang="XML" source="examples/targets/Configuration File/RoundRobinGroup/NLog.config" />
            <p>
            To set up the log target programmatically use code like this:
            </p>
            <code lang="C#" source="examples/targets/Configuration API/RoundRobinGroup/Simple/Example.cs" />
            </example>
        </member>
        <member name="M:NLog.Targets.Wrappers.RoundRobinGroupTarget.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.Wrappers.RoundRobinGroupTarget" /> class.
            </summary>
        </member>
        <member name="M:NLog.Targets.Wrappers.RoundRobinGroupTarget.#ctor(System.String,NLog.Targets.Target[])">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.Wrappers.RoundRobinGroupTarget" /> class.
            </summary>
            <param name="name">Name of the target.</param>
            <param name="targets">The targets.</param>
        </member>
        <member name="M:NLog.Targets.Wrappers.RoundRobinGroupTarget.#ctor(NLog.Targets.Target[])">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.Wrappers.RoundRobinGroupTarget" /> class.
            </summary>
            <param name="targets">The targets.</param>
        </member>
        <member name="M:NLog.Targets.Wrappers.RoundRobinGroupTarget.WriteAsyncThreadSafe(NLog.Common.AsyncLogEventInfo)">
            <summary>
            Ensures forwarding happens without holding lock
            </summary>
            <param name="logEvent"></param>
        </member>
        <member name="M:NLog.Targets.Wrappers.RoundRobinGroupTarget.Write(NLog.Common.AsyncLogEventInfo)">
            <summary>
            Forwards the write to one of the targets from
            the <see cref="N:NLog.Targets"/> collection.
            </summary>
            <param name="logEvent">The log event.</param>
            <remarks>
            The writes are routed in a round-robin fashion.
            The first log event goes to the first target, the second
            one goes to the second target and so on looping to the
            first target when there are no more targets available.
            In general request N goes to Targets[N % Targets.Count].
            </remarks>
        </member>
        <member name="T:NLog.Targets.Wrappers.SplitGroupTarget">
            <summary>
            Writes log events to all targets.
            </summary>
            <remarks>
            <a href="https://github.com/nlog/nlog/wiki/SplitGroup-target">See NLog Wiki</a>
            </remarks>
            <seealso href="https://github.com/nlog/nlog/wiki/SplitGroup-target">Documentation on NLog Wiki</seealso>
            <example>
            <p>This example causes the messages to be written to both file1.txt or file2.txt
            </p>
            <p>
            To set up the target in the <a href="https://github.com/NLog/NLog/wiki/Configuration-file">configuration file</a>,
            use the following syntax:
            </p>
            <code lang="XML" source="examples/targets/Configuration File/SplitGroup/NLog.config" />
            <p>
            To set up the log target programmatically use code like this:
            </p>
            <code lang="C#" source="examples/targets/Configuration API/SplitGroup/Simple/Example.cs" />
            </example>
        </member>
        <member name="M:NLog.Targets.Wrappers.SplitGroupTarget.#ctor">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.Wrappers.SplitGroupTarget" /> class.
            </summary>
        </member>
        <member name="M:NLog.Targets.Wrappers.SplitGroupTarget.#ctor(System.String,NLog.Targets.Target[])">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.Wrappers.SplitGroupTarget" /> class.
            </summary>
            <param name="name">Name of the target.</param>
            <param name="targets">The targets.</param>
        </member>
        <member name="M:NLog.Targets.Wrappers.SplitGroupTarget.#ctor(NLog.Targets.Target[])">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Targets.Wrappers.SplitGroupTarget" /> class.
            </summary>
            <param name="targets">The targets.</param>
        </member>
        <member name="M:NLog.Targets.Wrappers.SplitGroupTarget.Write(NLog.Common.AsyncLogEventInfo)">
            <summary>
            Forwards the specified log event to all sub-targets.
            </summary>
            <param name="logEvent">The log event.</param>
        </member>
        <member name="M:NLog.Targets.Wrappers.SplitGroupTarget.Write(System.Collections.Generic.IList{NLog.Common.AsyncLogEventInfo})">
            <summary>
            Writes an array of logging events to the log target. By default it iterates on all
            events and passes them to "Write" method. Inheriting classes can use this method to
            optimize batch writes.
            </summary>
            <param name="logEvents">Logging events to be written out.</param>
        </member>
        <member name="T:NLog.Targets.Wrappers.WrapperTargetBase">
            <summary>
            Base class for targets wrap other (single) targets.
            </summary>
        </member>
        <member name="P:NLog.Targets.Wrappers.WrapperTargetBase.WrappedTarget">
            <summary>
            Gets or sets the target that is wrapped by this target.
            </summary>
            <docgen category='General Options' order='11' />
        </member>
        <member name="M:NLog.Targets.Wrappers.WrapperTargetBase.ToString">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Targets.Wrappers.WrapperTargetBase.FlushAsync(NLog.Common.AsyncContinuation)">
            <inheritdoc/>
        </member>
        <member name="M:NLog.Targets.Wrappers.WrapperTargetBase.Write(NLog.LogEventInfo)">
            <summary>
            Writes logging event to the log target. Must be overridden in inheriting
            classes.
            </summary>
            <param name="logEvent">Logging event to be written out.</param>
        </member>
        <member name="T:NLog.Targets.ZipArchiveFileCompressor">
            <summary>
            Builtin IFileCompressor implementation utilizing the .Net4.5 specific <see cref="T:System.IO.Compression.ZipArchive"/>
            and is used as the default value for <see cref="P:NLog.Targets.FileTarget.FileCompressor"/> on .Net4.5.
            So log files created via <see cref="T:NLog.Targets.FileTarget"/> can be zipped when archived
            w/o 3rd party zip library when run on .Net4.5 or higher.
            </summary>
        </member>
        <member name="M:NLog.Targets.ZipArchiveFileCompressor.CompressFile(System.String,System.String)">
            <summary>
            Implements <see cref="M:NLog.Targets.IFileCompressor.CompressFile(System.String,System.String)"/> using the .Net4.5 specific <see cref="T:System.IO.Compression.ZipArchive"/>
            </summary>
        </member>
        <member name="T:NLog.Time.AccurateLocalTimeSource">
            <summary>
            Current local time retrieved directly from DateTime.Now.
            </summary>
        </member>
        <member name="P:NLog.Time.AccurateLocalTimeSource.Time">
            <summary>
            Gets current local time directly from DateTime.Now.
            </summary>
        </member>
        <member name="M:NLog.Time.AccurateLocalTimeSource.FromSystemTime(System.DateTime)">
            <summary>
             Converts the specified system time to the same form as the time value originated from this time source.
            </summary>
            <param name="systemTime">The system originated time value to convert.</param>
            <returns>
             The value of <paramref name="systemTime"/> converted to local time.
            </returns>
        </member>
        <member name="T:NLog.Time.AccurateUtcTimeSource">
            <summary>
            Current UTC time retrieved directly from DateTime.UtcNow.
            </summary>
        </member>
        <member name="P:NLog.Time.AccurateUtcTimeSource.Time">
            <summary>
            Gets current UTC time directly from DateTime.UtcNow.
            </summary>
        </member>
        <member name="M:NLog.Time.AccurateUtcTimeSource.FromSystemTime(System.DateTime)">
            <summary>
             Converts the specified system time to the same form as the time value originated from this time source.
            </summary>
            <param name="systemTime">The system originated time value to convert.</param>
            <returns>
             The value of <paramref name="systemTime"/> converted to UTC time.
            </returns>
        </member>
        <member name="T:NLog.Time.CachedTimeSource">
            <summary>
            Fast time source that updates current time only once per tick (15.6 milliseconds).
            </summary>
        </member>
        <member name="P:NLog.Time.CachedTimeSource.FreshTime">
            <summary>
            Gets raw uncached time from derived time source.
            </summary>
        </member>
        <member name="P:NLog.Time.CachedTimeSource.Time">
            <summary>
            Gets current time cached for one system tick (15.6 milliseconds).
            </summary>
        </member>
        <member name="T:NLog.Time.FastLocalTimeSource">
            <summary>
            Fast local time source that is updated once per tick (15.6 milliseconds).
            </summary>
        </member>
        <member name="P:NLog.Time.FastLocalTimeSource.FreshTime">
            <summary>
            Gets uncached local time directly from DateTime.Now.
            </summary>
        </member>
        <member name="M:NLog.Time.FastLocalTimeSource.FromSystemTime(System.DateTime)">
            <summary>
             Converts the specified system time to the same form as the time value originated from this time source.
            </summary>
            <param name="systemTime">The system originated time value to convert.</param>
            <returns>
             The value of <paramref name="systemTime"/> converted to local time.
            </returns>
        </member>
        <member name="T:NLog.Time.FastUtcTimeSource">
            <summary>
            Fast UTC time source that is updated once per tick (15.6 milliseconds).
            </summary>
        </member>
        <member name="P:NLog.Time.FastUtcTimeSource.FreshTime">
            <summary>
            Gets uncached UTC time directly from DateTime.UtcNow.
            </summary>
        </member>
        <member name="M:NLog.Time.FastUtcTimeSource.FromSystemTime(System.DateTime)">
            <summary>
             Converts the specified system time to the same form as the time value originated from this time source.
            </summary>
            <param name="systemTime">The system originated time value to convert.</param>
            <returns>
             The value of <paramref name="systemTime"/> converted to UTC time.
            </returns>
        </member>
        <member name="T:NLog.Time.TimeSource">
            <summary>
            Defines source of current time.
            </summary>
        </member>
        <member name="P:NLog.Time.TimeSource.Time">
            <summary>
            Gets current time.
            </summary>
        </member>
        <member name="P:NLog.Time.TimeSource.Current">
            <summary>
            Gets or sets current global time source used in all log events.
            </summary>
            <remarks>
            Default time source is <see cref="T:NLog.Time.FastLocalTimeSource"/>.
            </remarks>
        </member>
        <member name="M:NLog.Time.TimeSource.ToString">
            <summary>
            Returns a <see cref="T:System.String"/> that represents this instance.
            </summary>
            <returns>
            A <see cref="T:System.String"/> that represents this instance.
            </returns>
        </member>
        <member name="M:NLog.Time.TimeSource.FromSystemTime(System.DateTime)">
            <summary>
             Converts the specified system time to the same form as the time value originated from this time source.
            </summary>
            <param name="systemTime">The system originated time value to convert.</param>
            <returns>
             The value of <paramref name="systemTime"/> converted to the same form
             as time values originated from this source.
            </returns>
            <remarks>
             <para>
              There are situations when NLog have to compare the time originated from TimeSource
              to the time originated externally in the system.
              To be able to provide meaningful result of such comparisons the system time must be expressed in
              the same form as TimeSource time.
            </para>
            <para>
              Examples:
               - If the TimeSource provides time values of local time, it should also convert the provided
                 <paramref name="systemTime"/> to the local time.
               - If the TimeSource shifts or skews its time values, it should also apply
                 the same transform to the given <paramref name="systemTime"/>.
            </para>
            </remarks>
        </member>
        <member name="T:NLog.Time.TimeSourceAttribute">
            <summary>
            Marks class as a time source and assigns a name to it.
            </summary>
        </member>
        <member name="M:NLog.Time.TimeSourceAttribute.#ctor(System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:NLog.Time.TimeSourceAttribute" /> class.
            </summary>
            <param name="name">The Time type-alias for use in NLog configuration.</param>
        </member>
        <member name="M:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute.#ctor(System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes)">
            <summary>
            Initializes a new instance of the <see cref="T:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute"/> class
            with the specified member types.
            </summary>
            <param name="memberTypes">The types of members dynamically accessed.</param>
        </member>
        <member name="P:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMembersAttribute.MemberTypes">
            <summary>
            Gets the <see cref="T:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes"/> which specifies the type
            of members dynamically accessed.
            </summary>
        </member>
        <member name="T:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes">
             <summary>
             Specifies the types of members that are dynamically accessed.
            
             This enumeration has a <see cref="T:System.FlagsAttribute"/> attribute that allows a
             bitwise combination of its member values.
             </summary>
        </member>
        <member name="F:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.None">
            <summary>
            Specifies no members.
            </summary>
        </member>
        <member name="F:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicParameterlessConstructor">
            <summary>
            Specifies the default, parameterless public constructor.
            </summary>
        </member>
        <member name="F:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicConstructors">
            <summary>
            Specifies all public constructors.
            </summary>
        </member>
        <member name="F:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicConstructors">
            <summary>
            Specifies all non-public constructors.
            </summary>
        </member>
        <member name="F:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicMethods">
            <summary>
            Specifies all public methods.
            </summary>
        </member>
        <member name="F:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicMethods">
            <summary>
            Specifies all non-public methods.
            </summary>
        </member>
        <member name="F:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicFields">
            <summary>
            Specifies all public fields.
            </summary>
        </member>
        <member name="F:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicFields">
            <summary>
            Specifies all non-public fields.
            </summary>
        </member>
        <member name="F:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicNestedTypes">
            <summary>
            Specifies all public nested types.
            </summary>
        </member>
        <member name="F:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicNestedTypes">
            <summary>
            Specifies all non-public nested types.
            </summary>
        </member>
        <member name="F:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicProperties">
            <summary>
            Specifies all public properties.
            </summary>
        </member>
        <member name="F:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicProperties">
            <summary>
            Specifies all non-public properties.
            </summary>
        </member>
        <member name="F:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.PublicEvents">
            <summary>
            Specifies all public events.
            </summary>
        </member>
        <member name="F:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.NonPublicEvents">
            <summary>
            Specifies all non-public events.
            </summary>
        </member>
        <member name="F:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.Interfaces">
            <summary>
            Specifies all interfaces implemented by the type.
            </summary>
        </member>
        <member name="F:System.Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes.All">
            <summary>
            Specifies all members.
            </summary>
        </member>
        <member name="T:System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute">
            <summary>
            Suppresses reporting of a specific rule violation, allowing multiple suppressions on a
            single code artifact.
            </summary>
            <remarks>
            <see cref="T:System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute"/> is different than
            <see cref="T:System.Diagnostics.CodeAnalysis.SuppressMessageAttribute"/> in that it doesn't have a
            <see cref="T:System.Diagnostics.ConditionalAttribute"/>. So it is always preserved in the compiled assembly.
            </remarks>
        </member>
        <member name="M:System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute.#ctor(System.String,System.String)">
            <summary>
            Initializes a new instance of the <see cref="T:System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute"/>
            class, specifying the category of the tool and the identifier for an analysis rule.
            </summary>
            <param name="category">The category for the attribute.</param>
            <param name="checkId">The identifier of the analysis rule the attribute applies to.</param>
        </member>
        <member name="P:System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute.Category">
            <summary>
            Gets the category identifying the classification of the attribute.
            </summary>
            <remarks>
            The <see cref="P:System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute.Category"/> property describes the tool or tool analysis category
            for which a message suppression attribute applies.
            </remarks>
        </member>
        <member name="P:System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute.CheckId">
            <summary>
            Gets the identifier of the analysis tool rule to be suppressed.
            </summary>
            <remarks>
            Concatenated together, the <see cref="P:System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute.Category"/> and <see cref="P:System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute.CheckId"/>
            properties form a unique check identifier.
            </remarks>
        </member>
        <member name="P:System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute.Scope">
            <summary>
            Gets or sets the scope of the code that is relevant for the attribute.
            </summary>
            <remarks>
            The Scope property is an optional argument that specifies the metadata scope for which
            the attribute is relevant.
            </remarks>
        </member>
        <member name="P:System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute.Target">
            <summary>
            Gets or sets a fully qualified path that represents the target of the attribute.
            </summary>
            <remarks>
            The <see cref="P:System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute.Target"/> property is an optional argument identifying the analysis target
            of the attribute. An example value is "System.IO.Stream.ctor():System.Void".
            Because it is fully qualified, it can be long, particularly for targets such as parameters.
            The analysis tool user interface should be capable of automatically formatting the parameter.
            </remarks>
        </member>
        <member name="P:System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute.MessageId">
            <summary>
            Gets or sets an optional argument expanding on exclusion criteria.
            </summary>
            <remarks>
            The <see cref="P:System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute.MessageId"/> property is an optional argument that specifies additional
            exclusion where the literal metadata target is not sufficiently precise. For example,
            the <see cref="T:System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute"/> cannot be applied within a method,
            and it may be desirable to suppress a violation against a statement in the method that will
            give a rule violation, but not against all statements in the method.
            </remarks>
        </member>
        <member name="P:System.Diagnostics.CodeAnalysis.UnconditionalSuppressMessageAttribute.Justification">
            <summary>
            Gets or sets the justification for suppressing the code analysis message.
            </summary>
        </member>
    </members>
</doc>
